/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_depthwise_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/depthwise_conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using FilterBackpropWindow5Stride1 =
    sycldnn::depthwise_conv2d::WindowStrideTest<Pair, 5, 1>;
TYPED_TEST_SUITE(FilterBackpropWindow5Stride1, GTestTypePairs);
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5432.,  6940.,  8500.,  7180.,  5816.,  7990.,  10100., 12245., 10250.,
      8230.,  10740., 13470., 16206., 13470., 10740., 8230.,  10250., 12245.,
      10100., 7990.,  5816.,  7180.,  8500.,  6940.,  5432.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58.,  68.,  78.,  88.,  98.,  118., 128., 138., 148.,
      158., 178., 188., 198., 208., 218., 238., 248., 258.,
      268., 278., 298., 308., 318., 328., 338.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10680., 10864., 13640., 13880., 16700., 17000., 14100., 14360., 11416.,
      11632., 15690., 15980., 19825., 20200., 24025., 24490., 20100., 20500.,
      16130., 16460., 21060., 21480., 26400., 26940., 31746., 32412., 26370.,
      26940., 21012., 21480., 16050., 16460., 19975., 20500., 23845., 24490.,
      19650., 20200., 15530., 15980., 11256., 11632., 13880., 14360., 16412.,
      17000., 13380., 13880., 10456., 10864.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      98.,  116., 114., 136., 130., 156., 146., 176., 162., 196.,
      194., 236., 210., 256., 226., 276., 242., 296., 258., 316.,
      290., 356., 306., 376., 322., 396., 338., 416., 354., 436.,
      386., 476., 402., 496., 418., 516., 434., 536., 450., 556.,
      482., 596., 498., 616., 514., 636., 530., 656., 546., 676.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21176., 21360., 21544., 21728., 27040., 27280., 27520., 27760., 33100.,
      33400., 33700., 34000., 27940., 28200., 28460., 28720., 22616., 22832.,
      23048., 23264., 31090., 31380., 31670., 31960., 39275., 39650., 40025.,
      40400., 47585., 48050., 48515., 48980., 39800., 40200., 40600., 41000.,
      31930., 32260., 32590., 32920., 41700., 42120., 42540., 42960., 52260.,
      52800., 53340., 53880., 62826., 63492., 64158., 64824., 52170., 52740.,
      53310., 53880., 41556., 42024., 42492., 42960., 31690., 32100., 32510.,
      32920., 39425., 39950., 40475., 41000., 47045., 47690., 48335., 48980.,
      38750., 39300., 39850., 40400., 30610., 31060., 31510., 31960., 22136.,
      22512., 22888., 23264., 27280., 27760., 28240., 28720., 32236., 32824.,
      33412., 34000., 26260., 26760., 27260., 27760., 20504., 20912., 21320.,
      21728.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      178.,  196.,  214.,  232.,  206.,  228.,  250.,  272.,  234.,  260.,
      286.,  312.,  262.,  292.,  322.,  352.,  290.,  324.,  358.,  392.,
      346.,  388.,  430.,  472.,  374.,  420.,  466.,  512.,  402.,  452.,
      502.,  552.,  430.,  484.,  538.,  592.,  458.,  516.,  574.,  632.,
      514.,  580.,  646.,  712.,  542.,  612.,  682.,  752.,  570.,  644.,
      718.,  792.,  598.,  676.,  754.,  832.,  626.,  708.,  790.,  872.,
      682.,  772.,  862.,  952.,  710.,  804.,  898.,  992.,  738.,  836.,
      934.,  1032., 766.,  868.,  970.,  1072., 794.,  900.,  1006., 1112.,
      850.,  964.,  1078., 1192., 878.,  996.,  1114., 1232., 906.,  1028.,
      1150., 1272., 934.,  1060., 1186., 1312., 962.,  1092., 1222., 1352.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20560., 21728., 26300., 27760., 32248., 34000., 27260., 28720., 22096.,
      23264., 30500., 31960., 38575., 40400., 46790., 48980., 39175., 41000.,
      31460., 32920., 41208., 42960., 51690., 53880., 62196., 64824., 51690.,
      53880., 41208., 42960., 31460., 32920., 39175., 41000., 46790., 48980.,
      38575., 40400., 30500., 31960., 22096., 23264., 27260., 28720., 32248.,
      34000., 26300., 27760., 20560., 21728.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      180., 232.,  212., 272.,  244.,  312.,  276.,  352.,  308.,  392.,
      372., 472.,  404., 512.,  436.,  552.,  468.,  592.,  500.,  632.,
      564., 712.,  596., 752.,  628.,  792.,  660.,  832.,  692.,  872.,
      756., 952.,  788., 992.,  820.,  1032., 852.,  1072., 884.,  1112.,
      948., 1192., 980., 1232., 1012., 1272., 1044., 1312., 1076., 1352.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      40768.,  41120.,  43088.,  43456.,  52140.,  52600.,  55040.,  55520.,
      63920.,  64496.,  67400.,  68000.,  54020.,  54520.,  56920.,  57440.,
      43776.,  44192.,  46096.,  46528.,  60440.,  61000.,  63340.,  63920.,
      76425.,  77150.,  80050.,  80800.,  92680.,  93580.,  97030.,  97960.,
      77575.,  78350.,  81200.,  82000.,  62280.,  62920.,  65180.,  65840.,
      81600.,  82416.,  85080.,  85920.,  102330., 103380., 106680., 107760.,
      123096., 124392., 128316., 129648., 102270., 103380., 106620., 107760.,
      81504.,  82416.,  84984.,  85920.,  62120.,  62920.,  65020.,  65840.,
      77325.,  78350.,  80950.,  82000.,  92320.,  93580.,  96670.,  97960.,
      76075.,  77150.,  79700.,  80800.,  60120.,  61000.,  63020.,  63920.,
      43456.,  44192.,  45776.,  46528.,  53580.,  54520.,  56480.,  57440.,
      63344.,  64496.,  66824.,  68000.,  51620.,  52600.,  54520.,  55520.,
      40320.,  41120.,  42640.,  43456.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      328.,  360.,  428.,  464.,  384.,  424.,  500.,  544.,  440.,  488.,
      572.,  624.,  496.,  552.,  644.,  704.,  552.,  616.,  716.,  784.,
      664.,  744.,  860.,  944.,  720.,  808.,  932.,  1024., 776.,  872.,
      1004., 1104., 832.,  936.,  1076., 1184., 888.,  1000., 1148., 1264.,
      1000., 1128., 1292., 1424., 1056., 1192., 1364., 1504., 1112., 1256.,
      1436., 1584., 1168., 1320., 1508., 1664., 1224., 1384., 1580., 1744.,
      1336., 1512., 1724., 1904., 1392., 1576., 1796., 1984., 1448., 1640.,
      1868., 2064., 1504., 1704., 1940., 2144., 1560., 1768., 2012., 2224.,
      1672., 1896., 2156., 2384., 1728., 1960., 2228., 2464., 1784., 2024.,
      2300., 2544., 1840., 2088., 2372., 2624., 1896., 2152., 2444., 2704.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      81184.,  81536.,  81888.,  82240.,  85808.,  86176.,  86544.,  86912.,
      103820., 104280., 104740., 105200., 109600., 110080., 110560., 111040.,
      127264., 127840., 128416., 128992., 134200., 134800., 135400., 136000.,
      107540., 108040., 108540., 109040., 113320., 113840., 114360., 114880.,
      87136.,  87552.,  87968.,  88384.,  91760.,  92192.,  92624.,  93056.,
      120320., 120880., 121440., 122000., 126100., 126680., 127260., 127840.,
      152125., 152850., 153575., 154300., 159350., 160100., 160850., 161600.,
      184460., 185360., 186260., 187160., 193130., 194060., 194990., 195920.,
      154375., 155150., 155925., 156700., 161600., 162400., 163200., 164000.,
      123920., 124560., 125200., 125840., 129700., 130360., 131020., 131680.,
      162384., 163200., 164016., 164832., 169320., 170160., 171000., 171840.,
      203610., 204660., 205710., 206760., 212280., 213360., 214440., 215520.,
      244896., 246192., 247488., 248784., 255300., 256632., 257964., 259296.,
      203430., 204540., 205650., 206760., 212100., 213240., 214380., 215520.,
      162096., 163008., 163920., 164832., 169032., 169968., 170904., 171840.,
      123440., 124240., 125040., 125840., 129220., 130040., 130860., 131680.,
      153625., 154650., 155675., 156700., 160850., 161900., 162950., 164000.,
      183380., 184640., 185900., 187160., 192050., 193340., 194630., 195920.,
      151075., 152150., 153225., 154300., 158300., 159400., 160500., 161600.,
      119360., 120240., 121120., 122000., 125140., 126040., 126940., 127840.,
      86176.,  86912.,  87648.,  88384.,  90800.,  91552.,  92304.,  93056.,
      106220., 107160., 108100., 109040., 112000., 112960., 113920., 114880.,
      125536., 126688., 127840., 128992., 132472., 133648., 134824., 136000.,
      102260., 103240., 104220., 105200., 108040., 109040., 110040., 111040.,
      79840.,  80640.,  81440.,  82240.,  84464.,  85280.,  86096.,  86912.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      624.,  656.,  688.,  720.,  820.,  856.,  892.,  928.,  728.,  768.,
      808.,  848.,  956.,  1000., 1044., 1088., 832.,  880.,  928.,  976.,
      1092., 1144., 1196., 1248., 936.,  992.,  1048., 1104., 1228., 1288.,
      1348., 1408., 1040., 1104., 1168., 1232., 1364., 1432., 1500., 1568.,
      1248., 1328., 1408., 1488., 1636., 1720., 1804., 1888., 1352., 1440.,
      1528., 1616., 1772., 1864., 1956., 2048., 1456., 1552., 1648., 1744.,
      1908., 2008., 2108., 2208., 1560., 1664., 1768., 1872., 2044., 2152.,
      2260., 2368., 1664., 1776., 1888., 2000., 2180., 2296., 2412., 2528.,
      1872., 2000., 2128., 2256., 2452., 2584., 2716., 2848., 1976., 2112.,
      2248., 2384., 2588., 2728., 2868., 3008., 2080., 2224., 2368., 2512.,
      2724., 2872., 3020., 3168., 2184., 2336., 2488., 2640., 2860., 3016.,
      3172., 3328., 2288., 2448., 2608., 2768., 2996., 3160., 3324., 3488.,
      2496., 2672., 2848., 3024., 3268., 3448., 3628., 3808., 2600., 2784.,
      2968., 3152., 3404., 3592., 3780., 3968., 2704., 2896., 3088., 3280.,
      3540., 3736., 3932., 4128., 2808., 3008., 3208., 3408., 3676., 3880.,
      4084., 4288., 2912., 3120., 3328., 3536., 3812., 4024., 4236., 4448.,
      3120., 3344., 3568., 3792., 4084., 4312., 4540., 4768., 3224., 3456.,
      3688., 3920., 4220., 4456., 4692., 4928., 3328., 3568., 3808., 4048.,
      4356., 4600., 4844., 5088., 3432., 3680., 3928., 4176., 4492., 4744.,
      4996., 5248., 3536., 3792., 4048., 4304., 4628., 4888., 5148., 5408.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      79952.,  82240.,  84560.,  86912.,  102340., 105200., 108100., 111040.,
      125560., 128992., 132472., 136000., 106180., 109040., 111940., 114880.,
      86096.,  88384.,  90704.,  93056.,  119140., 122000., 124900., 127840.,
      150725., 154300., 157925., 161600., 182870., 187160., 191510., 195920.,
      153125., 156700., 160325., 164000., 122980., 125840., 128740., 131680.,
      161400., 164832., 168312., 171840., 202470., 206760., 211110., 215520.,
      243636., 248784., 254004., 259296., 202470., 206760., 211110., 215520.,
      161400., 164832., 168312., 171840., 122980., 125840., 128740., 131680.,
      153125., 156700., 160325., 164000., 182870., 187160., 191510., 195920.,
      150725., 154300., 157925., 161600., 119140., 122000., 124900., 127840.,
      86096.,  88384.,  90704.,  93056.,  106180., 109040., 111940., 114880.,
      125560., 128992., 132472., 136000., 102340., 105200., 108100., 111040.,
      79952.,  82240.,  84560.,  86912.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      628.,  720.,  820.,  928.,  740.,  848.,  964.,  1088., 852.,  976.,
      1108., 1248., 964.,  1104., 1252., 1408., 1076., 1232., 1396., 1568.,
      1300., 1488., 1684., 1888., 1412., 1616., 1828., 2048., 1524., 1744.,
      1972., 2208., 1636., 1872., 2116., 2368., 1748., 2000., 2260., 2528.,
      1972., 2256., 2548., 2848., 2084., 2384., 2692., 3008., 2196., 2512.,
      2836., 3168., 2308., 2640., 2980., 3328., 2420., 2768., 3124., 3488.,
      2644., 3024., 3412., 3808., 2756., 3152., 3556., 3968., 2868., 3280.,
      3700., 4128., 2980., 3408., 3844., 4288., 3092., 3536., 3988., 4448.,
      3316., 3792., 4276., 4768., 3428., 3920., 4420., 4928., 3540., 4048.,
      4564., 5088., 3652., 4176., 4708., 5248., 3764., 4304., 4852., 5408.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      159216., 159904., 163776., 164480., 168400., 169120., 173088., 173824.,
      203780., 204680., 209480., 210400., 215260., 216200., 221120., 222080.,
      249992., 251120., 256832., 257984., 263768., 264944., 270800., 272000.,
      211380., 212360., 217080., 218080., 222860., 223880., 228720., 229760.,
      171376., 172192., 175936., 176768., 180560., 181408., 185248., 186112.,
      237180., 238280., 242880., 244000., 248660., 249800., 254520., 255680.,
      300025., 301450., 307150., 308600., 314375., 315850., 321700., 323200.,
      363970., 365740., 372520., 374320., 381190., 383020., 389980., 391840.,
      304725., 306250., 311850., 313400., 319075., 320650., 326400., 328000.,
      244700., 245960., 250400., 251680., 256180., 257480., 262040., 263360.,
      321192., 322800., 328032., 329664., 334968., 336624., 342000., 343680.,
      402870., 404940., 411420., 413520., 420090., 422220., 428880., 431040.,
      484716., 487272., 494976., 497568., 505380., 508008., 515928., 518592.,
      402750., 404940., 411300., 413520., 419970., 422220., 428760., 431040.,
      321000., 322800., 327840., 329664., 334776., 336624., 341808., 343680.,
      244380., 245960., 250080., 251680., 255860., 257480., 261720., 263360.,
      304225., 306250., 311350., 313400., 318575., 320650., 325900., 328000.,
      363250., 365740., 371800., 374320., 380470., 383020., 389260., 391840.,
      299325., 301450., 306450., 308600., 313675., 315850., 321000., 323200.,
      236540., 238280., 242240., 244000., 248020., 249800., 253880., 255680.,
      170736., 172192., 175296., 176768., 179920., 181408., 184608., 186112.,
      210500., 212360., 216200., 218080., 221980., 223880., 227840., 229760.,
      248840., 251120., 255680., 257984., 262616., 264944., 269648., 272000.,
      202740., 204680., 208440., 210400., 214220., 216200., 220080., 222080.,
      158320., 159904., 162880., 164480., 167504., 169120., 172192., 173824.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1196., 1256.,  1376., 1440.,  1572., 1640., 1784., 1856., 1404.,  1480.,
      1616., 1696.,  1844., 1928.,  2088., 2176., 1612., 1704., 1856.,  1952.,
      2116., 2216.,  2392., 2496.,  1820., 1928., 2096., 2208., 2388.,  2504.,
      2696., 2816.,  2028., 2152.,  2336., 2464., 2660., 2792., 3000.,  3136.,
      2444., 2600.,  2816., 2976.,  3204., 3368., 3608., 3776., 2652.,  2824.,
      3056., 3232.,  3476., 3656.,  3912., 4096., 2860., 3048., 3296.,  3488.,
      3748., 3944.,  4216., 4416.,  3068., 3272., 3536., 3744., 4020.,  4232.,
      4520., 4736.,  3276., 3496.,  3776., 4000., 4292., 4520., 4824.,  5056.,
      3692., 3944.,  4256., 4512.,  4836., 5096., 5432., 5696., 3900.,  4168.,
      4496., 4768.,  5108., 5384.,  5736., 6016., 4108., 4392., 4736.,  5024.,
      5380., 5672.,  6040., 6336.,  4316., 4616., 4976., 5280., 5652.,  5960.,
      6344., 6656.,  4524., 4840.,  5216., 5536., 5924., 6248., 6648.,  6976.,
      4940., 5288.,  5696., 6048.,  6468., 6824., 7256., 7616., 5148.,  5512.,
      5936., 6304.,  6740., 7112.,  7560., 7936., 5356., 5736., 6176.,  6560.,
      7012., 7400.,  7864., 8256.,  5564., 5960., 6416., 6816., 7284.,  7688.,
      8168., 8576.,  5772., 6184.,  6656., 7072., 7556., 7976., 8472.,  8896.,
      6188., 6632.,  7136., 7584.,  8100., 8552., 9080., 9536., 6396.,  6856.,
      7376., 7840.,  8372., 8840.,  9384., 9856., 6604., 7080., 7616.,  8096.,
      8644., 9128.,  9688., 10176., 6812., 7304., 7856., 8352., 8916.,  9416.,
      9992., 10496., 7020., 7528.,  8096., 8608., 9188., 9704., 10296., 10816.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      317744.,  318432.,  319120.,  319808.,  326848.,  327552.,  328256.,
      328960.,  336080.,  336800.,  337520.,  338240.,  345440.,  346176.,
      346912.,  347648.,  406660.,  407560.,  408460.,  409360.,  418040.,
      418960.,  419880.,  420800.,  429580.,  430520.,  431460.,  432400.,
      441280.,  442240.,  443200.,  444160.,  498856.,  499984.,  501112.,
      502240.,  512512.,  513664.,  514816.,  515968.,  526360.,  527536.,
      528712.,  529888.,  540400.,  541600.,  542800.,  544000.,  421780.,
      422760.,  423740.,  424720.,  433160.,  434160.,  435160.,  436160.,
      444700.,  445720.,  446740.,  447760.,  456400.,  457440.,  458480.,
      459520.,  341936.,  342752.,  343568.,  344384.,  351040.,  351872.,
      352704.,  353536.,  360272.,  361120.,  361968.,  362816.,  369632.,
      370496.,  371360.,  372224.,  473260.,  474360.,  475460.,  476560.,
      484640.,  485760.,  486880.,  488000.,  496180.,  497320.,  498460.,
      499600.,  507880.,  509040.,  510200.,  511360.,  598625.,  600050.,
      601475.,  602900.,  612850.,  614300.,  615750.,  617200.,  627275.,
      628750.,  630225.,  631700.,  641900.,  643400.,  644900.,  646400.,
      726170.,  727940.,  729710.,  731480.,  743240.,  745040.,  746840.,
      748640.,  760550.,  762380.,  764210.,  766040.,  778100.,  779960.,
      781820.,  783680.,  607925.,  609450.,  610975.,  612500.,  622150.,
      623700.,  625250.,  626800.,  636575.,  638150.,  639725.,  641300.,
      651200.,  652800.,  654400.,  656000.,  488140.,  489400.,  490660.,
      491920.,  499520.,  500800.,  502080.,  503360.,  511060.,  512360.,
      513660.,  514960.,  522760.,  524080.,  525400.,  526720.,  640776.,
      642384.,  643992.,  645600.,  654432.,  656064.,  657696.,  659328.,
      668280.,  669936.,  671592.,  673248.,  682320.,  684000.,  685680.,
      687360.,  803670.,  805740.,  807810.,  809880.,  820740.,  822840.,
      824940.,  827040.,  838050.,  840180.,  842310.,  844440.,  855600.,
      857760.,  859920.,  862080.,  966876.,  969432.,  971988.,  974544.,
      987360.,  989952.,  992544.,  995136.,  1008132., 1010760., 1013388.,
      1016016., 1029192., 1031856., 1034520., 1037184., 803310.,  805500.,
      807690.,  809880.,  820380.,  822600.,  824820.,  827040.,  837690.,
      839940.,  842190.,  844440.,  855240.,  857520.,  859800.,  862080.,
      640200.,  642000.,  643800.,  645600.,  653856.,  655680.,  657504.,
      659328.,  667704.,  669552.,  671400.,  673248.,  681744.,  683616.,
      685488.,  687360.,  487180.,  488760.,  490340.,  491920.,  498560.,
      500160.,  501760.,  503360.,  510100.,  511720.,  513340.,  514960.,
      521800.,  523440.,  525080.,  526720.,  606425.,  608450.,  610475.,
      612500.,  620650.,  622700.,  624750.,  626800.,  635075.,  637150.,
      639225.,  641300.,  649700.,  651800.,  653900.,  656000.,  724010.,
      726500.,  728990.,  731480.,  741080.,  743600.,  746120.,  748640.,
      758390.,  760940.,  763490.,  766040.,  775940.,  778520.,  781100.,
      783680.,  596525.,  598650.,  600775.,  602900.,  610750.,  612900.,
      615050.,  617200.,  625175.,  627350.,  629525.,  631700.,  639800.,
      642000.,  644200.,  646400.,  471340.,  473080.,  474820.,  476560.,
      482720.,  484480.,  486240.,  488000.,  494260.,  496040.,  497820.,
      499600.,  505960.,  507760.,  509560.,  511360.,  340016.,  341472.,
      342928.,  344384.,  349120.,  350592.,  352064.,  353536.,  358352.,
      359840.,  361328.,  362816.,  367712.,  369216.,  370720.,  372224.,
      419140.,  421000.,  422860.,  424720.,  430520.,  432400.,  434280.,
      436160.,  442060.,  443960.,  445860.,  447760.,  453760.,  455680.,
      457600.,  459520.,  495400.,  497680.,  499960.,  502240.,  509056.,
      511360.,  513664.,  515968.,  522904.,  525232.,  527560.,  529888.,
      536944.,  539296.,  541648.,  544000.,  403540.,  405480.,  407420.,
      409360.,  414920.,  416880.,  418840.,  420800.,  426460.,  428440.,
      430420.,  432400.,  438160.,  440160.,  442160.,  444160.,  315056.,
      316640.,  318224.,  319808.,  324160.,  325760.,  327360.,  328960.,
      333392.,  335008.,  336624.,  338240.,  342752.,  344384.,  346016.,
      347648.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2332.,  2392.,  2452.,  2512.,  2688.,  2752.,  2816.,  2880.,  3076.,
      3144.,  3212.,  3280.,  3496.,  3568.,  3640.,  3712.,  2732.,  2808.,
      2884.,  2960.,  3152.,  3232.,  3312.,  3392.,  3604.,  3688.,  3772.,
      3856.,  4088.,  4176.,  4264.,  4352.,  3132.,  3224.,  3316.,  3408.,
      3616.,  3712.,  3808.,  3904.,  4132.,  4232.,  4332.,  4432.,  4680.,
      4784.,  4888.,  4992.,  3532.,  3640.,  3748.,  3856.,  4080.,  4192.,
      4304.,  4416.,  4660.,  4776.,  4892.,  5008.,  5272.,  5392.,  5512.,
      5632.,  3932.,  4056.,  4180.,  4304.,  4544.,  4672.,  4800.,  4928.,
      5188.,  5320.,  5452.,  5584.,  5864.,  6000.,  6136.,  6272.,  4732.,
      4888.,  5044.,  5200.,  5472.,  5632.,  5792.,  5952.,  6244.,  6408.,
      6572.,  6736.,  7048.,  7216.,  7384.,  7552.,  5132.,  5304.,  5476.,
      5648.,  5936.,  6112.,  6288.,  6464.,  6772.,  6952.,  7132.,  7312.,
      7640.,  7824.,  8008.,  8192.,  5532.,  5720.,  5908.,  6096.,  6400.,
      6592.,  6784.,  6976.,  7300.,  7496.,  7692.,  7888.,  8232.,  8432.,
      8632.,  8832.,  5932.,  6136.,  6340.,  6544.,  6864.,  7072.,  7280.,
      7488.,  7828.,  8040.,  8252.,  8464.,  8824.,  9040.,  9256.,  9472.,
      6332.,  6552.,  6772.,  6992.,  7328.,  7552.,  7776.,  8000.,  8356.,
      8584.,  8812.,  9040.,  9416.,  9648.,  9880.,  10112., 7132.,  7384.,
      7636.,  7888.,  8256.,  8512.,  8768.,  9024.,  9412.,  9672.,  9932.,
      10192., 10600., 10864., 11128., 11392., 7532.,  7800.,  8068.,  8336.,
      8720.,  8992.,  9264.,  9536.,  9940.,  10216., 10492., 10768., 11192.,
      11472., 11752., 12032., 7932.,  8216.,  8500.,  8784.,  9184.,  9472.,
      9760.,  10048., 10468., 10760., 11052., 11344., 11784., 12080., 12376.,
      12672., 8332.,  8632.,  8932.,  9232.,  9648.,  9952.,  10256., 10560.,
      10996., 11304., 11612., 11920., 12376., 12688., 13000., 13312., 8732.,
      9048.,  9364.,  9680.,  10112., 10432., 10752., 11072., 11524., 11848.,
      12172., 12496., 12968., 13296., 13624., 13952., 9532.,  9880.,  10228.,
      10576., 11040., 11392., 11744., 12096., 12580., 12936., 13292., 13648.,
      14152., 14512., 14872., 15232., 9932.,  10296., 10660., 11024., 11504.,
      11872., 12240., 12608., 13108., 13480., 13852., 14224., 14744., 15120.,
      15496., 15872., 10332., 10712., 11092., 11472., 11968., 12352., 12736.,
      13120., 13636., 14024., 14412., 14800., 15336., 15728., 16120., 16512.,
      10732., 11128., 11524., 11920., 12432., 12832., 13232., 13632., 14164.,
      14568., 14972., 15376., 15928., 16336., 16744., 17152., 11132., 11544.,
      11956., 12368., 12896., 13312., 13728., 14144., 14692., 15112., 15532.,
      15952., 16520., 16944., 17368., 17792., 11932., 12376., 12820., 13264.,
      13824., 14272., 14720., 15168., 15748., 16200., 16652., 17104., 17704.,
      18160., 18616., 19072., 12332., 12792., 13252., 13712., 14288., 14752.,
      15216., 15680., 16276., 16744., 17212., 17680., 18296., 18768., 19240.,
      19712., 12732., 13208., 13684., 14160., 14752., 15232., 15712., 16192.,
      16804., 17288., 17772., 18256., 18888., 19376., 19864., 20352., 13132.,
      13624., 14116., 14608., 15216., 15712., 16208., 16704., 17332., 17832.,
      18332., 18832., 19480., 19984., 20488., 20992., 13532., 14040., 14548.,
      15056., 15680., 16192., 16704., 17216., 17860., 18376., 18892., 19408.,
      20072., 20592., 21112., 21632.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9230.,  11284., 13398., 11620., 9790.,  13550., 16415., 19320., 16625.,
      13900., 18185., 21882., 25585., 21882., 18185., 13900., 16625., 19320.,
      16415., 13550., 9790.,  11620., 13398., 11284., 9230.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      151., 172., 193., 214., 235., 298., 319., 340., 361.,
      382., 445., 466., 487., 508., 529., 592., 613., 634.,
      655., 676., 739., 760., 781., 802., 823.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18190., 18460., 22232., 22568., 26390., 26796., 22880., 23240., 19270.,
      19580., 26675., 27100., 32305., 32830., 38010., 38640., 32695., 33250.,
      27325., 27800., 35755., 36370., 43008., 43764., 50267., 51170., 42972.,
      43764., 35695., 36370., 27200., 27800., 32515., 33250., 37765., 38640.,
      32065., 32830., 26450., 27100., 19030., 19580., 22568., 23240., 25998.,
      26796., 21872., 22568., 17870., 18460.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      269.,  302.,  305.,  344.,  341.,  386.,  377.,  428.,  413.,  470.,
      521.,  596.,  557.,  638.,  593.,  680.,  629.,  722.,  665.,  764.,
      773.,  890.,  809.,  932.,  845.,  974.,  881.,  1016., 917.,  1058.,
      1025., 1184., 1061., 1226., 1097., 1268., 1133., 1310., 1169., 1352.,
      1277., 1478., 1313., 1520., 1349., 1562., 1385., 1604., 1421., 1646.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      36110., 36380., 36650., 36920., 44128.,  44464.,  44800.,  45136., 52374.,
      52780., 53186., 53592., 45400., 45760.,  46120.,  46480.,  38230., 38540.,
      38850., 39160., 52925., 53350., 53775.,  54200.,  64085.,  64610., 65135.,
      65660., 75390., 76020., 76650., 77280.,  64835.,  65390.,  65945., 66500.,
      54175., 54650., 55125., 55600., 70895.,  71510.,  72125.,  72740., 85260.,
      86016., 86772., 87528., 99631., 100534., 101437., 102340., 85152., 85944.,
      86736., 87528., 70715., 71390., 72065.,  72740.,  53800.,  54400., 55000.,
      55600., 64295., 65030., 65765., 66500.,  74655.,  75530.,  76405., 77280.,
      63365., 64130., 64895., 65660., 52250.,  52900.,  53550.,  54200., 37510.,
      38060., 38610., 39160., 44464., 45136.,  45808.,  46480.,  51198., 51996.,
      52794., 53592., 43048., 43744., 44440.,  45136.,  35150.,  35740., 36330.,
      36920.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      505.,  538.,  571.,  604.,  571.,  610.,  649.,  688.,  637.,  682.,
      727.,  772.,  703.,  754.,  805.,  856.,  769.,  826.,  883.,  940.,
      967.,  1042., 1117., 1192., 1033., 1114., 1195., 1276., 1099., 1186.,
      1273., 1360., 1165., 1258., 1351., 1444., 1231., 1330., 1429., 1528.,
      1429., 1546., 1663., 1780., 1495., 1618., 1741., 1864., 1561., 1690.,
      1819., 1948., 1627., 1762., 1897., 2032., 1693., 1834., 1975., 2116.,
      1891., 2050., 2209., 2368., 1957., 2122., 2287., 2452., 2023., 2194.,
      2365., 2536., 2089., 2266., 2443., 2620., 2155., 2338., 2521., 2704.,
      2353., 2554., 2755., 2956., 2419., 2626., 2833., 3040., 2485., 2698.,
      2911., 3124., 2551., 2770., 2989., 3208., 2617., 2842., 3067., 3292.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35220., 36920., 43096., 45136., 51212., 53592., 44440., 46480.,  37460.,
      39160., 52075., 54200., 63110., 65660., 74305., 77280., 63950.,  66500.,
      53475., 55600., 70190., 72740., 84468., 87528., 98770., 102340., 84468.,
      87528., 70190., 72740., 53475., 55600., 63950., 66500., 74305.,  77280.,
      63110., 65660., 52075., 54200., 37460., 39160., 44440., 46480.,  51212.,
      53592., 43096., 45136., 35220., 36920.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      502.,  604.,  574.,  688.,  646.,  772.,  718.,  856.,  790.,  940.,
      1006., 1192., 1078., 1276., 1150., 1360., 1222., 1444., 1294., 1528.,
      1510., 1780., 1582., 1864., 1654., 1948., 1726., 2032., 1798., 2116.,
      2014., 2368., 2086., 2452., 2158., 2536., 2230., 2620., 2302., 2704.,
      2518., 2956., 2590., 3040., 2662., 3124., 2734., 3208., 2806., 3292.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69920.,  70440.,  73300.,  73840.,  85544.,  86192.,  89600.,  90272.,
      101640., 102424., 106372., 107184., 88184.,  88880.,  92240.,  92960.,
      74320.,  74920.,  77700.,  78320.,  103325., 104150., 107550., 108400.,
      125200., 126220., 130270., 131320., 147385., 148610., 153300., 154560.,
      126820., 127900., 131890., 133000., 106025., 106950., 110250., 111200.,
      139180., 140380., 144250., 145480., 167460., 168936., 173544., 175056.,
      195776., 197540., 202874., 204680., 167388., 168936., 173472., 175056.,
      139060., 140380., 144130., 145480., 105775., 106950., 110000., 111200.,
      126460., 127900., 131530., 133000., 146895., 148610., 152810., 154560.,
      124720., 126220., 129790., 131320., 102875., 104150., 107100., 108400.,
      73840.,  74920.,  77220.,  78320.,  87560.,  88880.,  91616.,  92960.,
      100856., 102424., 105588., 107184., 84824.,  86192.,  88880.,  90272.,
      69280.,  70440.,  72660.,  73840.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      944.,  1004., 1142., 1208., 1076., 1148., 1298., 1376., 1208., 1292.,
      1454., 1544., 1340., 1436., 1610., 1712., 1472., 1580., 1766., 1880.,
      1868., 2012., 2234., 2384., 2000., 2156., 2390., 2552., 2132., 2300.,
      2546., 2720., 2264., 2444., 2702., 2888., 2396., 2588., 2858., 3056.,
      2792., 3020., 3326., 3560., 2924., 3164., 3482., 3728., 3056., 3308.,
      3638., 3896., 3188., 3452., 3794., 4064., 3320., 3596., 3950., 4232.,
      3716., 4028., 4418., 4736., 3848., 4172., 4574., 4904., 3980., 4316.,
      4730., 5072., 4112., 4460., 4886., 5240., 4244., 4604., 5042., 5408.,
      4640., 5036., 5510., 5912., 4772., 5180., 5666., 6080., 4904., 5324.,
      5822., 6248., 5036., 5468., 5978., 6416., 5168., 5612., 6134., 6584.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      139320., 139840., 140360., 140880., 146060., 146600., 147140., 147680.,
      170440., 171088., 171736., 172384., 178528., 179200., 179872., 180544.,
      202496., 203280., 204064., 204848., 211932., 212744., 213556., 214368.,
      175672., 176368., 177064., 177760., 183760., 184480., 185200., 185920.,
      148040., 148640., 149240., 149840., 154780., 155400., 156020., 156640.,
      205825., 206650., 207475., 208300., 214250., 215100., 215950., 216800.,
      249380., 250400., 251420., 252440., 259490., 260540., 261590., 262640.,
      293545., 294770., 295995., 297220., 305340., 306600., 307860., 309120.,
      252560., 253640., 254720., 255800., 262670., 263780., 264890., 266000.,
      211125., 212050., 212975., 213900., 219550., 220500., 221450., 222400.,
      277160., 278360., 279560., 280760., 287270., 288500., 289730., 290960.,
      333444., 334920., 336396., 337872., 345576., 347088., 348600., 350112.,
      389788., 391552., 393316., 395080., 403942., 405748., 407554., 409360.,
      333228., 334776., 336324., 337872., 345360., 346944., 348528., 350112.,
      276800., 278120., 279440., 280760., 286910., 288260., 289610., 290960.,
      210375., 211550., 212725., 213900., 218800., 220000., 221200., 222400.,
      251480., 252920., 254360., 255800., 261590., 263060., 264530., 266000.,
      292075., 293790., 295505., 297220., 303870., 305620., 307370., 309120.,
      247940., 249440., 250940., 252440., 258050., 259580., 261110., 262640.,
      204475., 205750., 207025., 208300., 212900., 214200., 215500., 216800.,
      146600., 147680., 148760., 149840., 153340., 154440., 155540., 156640.,
      173800., 175120., 176440., 177760., 181888., 183232., 184576., 185920.,
      200144., 201712., 203280., 204848., 209580., 211176., 212772., 214368.,
      168280., 169648., 171016., 172384., 176368., 177760., 179152., 180544.,
      137400., 138560., 139720., 140880., 144140., 145320., 146500., 147680.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1828.,  1888.,  1948.,  2008.,  2218.,  2284.,  2350.,  2416.,  2080.,
      2152.,  2224.,  2296.,  2518.,  2596.,  2674.,  2752.,  2332.,  2416.,
      2500.,  2584.,  2818.,  2908.,  2998.,  3088.,  2584.,  2680.,  2776.,
      2872.,  3118.,  3220.,  3322.,  3424.,  2836.,  2944.,  3052.,  3160.,
      3418.,  3532.,  3646.,  3760.,  3592.,  3736.,  3880.,  4024.,  4318.,
      4468.,  4618.,  4768.,  3844.,  4000.,  4156.,  4312.,  4618.,  4780.,
      4942.,  5104.,  4096.,  4264.,  4432.,  4600.,  4918.,  5092.,  5266.,
      5440.,  4348.,  4528.,  4708.,  4888.,  5218.,  5404.,  5590.,  5776.,
      4600.,  4792.,  4984.,  5176.,  5518.,  5716.,  5914.,  6112.,  5356.,
      5584.,  5812.,  6040.,  6418.,  6652.,  6886.,  7120.,  5608.,  5848.,
      6088.,  6328.,  6718.,  6964.,  7210.,  7456.,  5860.,  6112.,  6364.,
      6616.,  7018.,  7276.,  7534.,  7792.,  6112.,  6376.,  6640.,  6904.,
      7318.,  7588.,  7858.,  8128.,  6364.,  6640.,  6916.,  7192.,  7618.,
      7900.,  8182.,  8464.,  7120.,  7432.,  7744.,  8056.,  8518.,  8836.,
      9154.,  9472.,  7372.,  7696.,  8020.,  8344.,  8818.,  9148.,  9478.,
      9808.,  7624.,  7960.,  8296.,  8632.,  9118.,  9460.,  9802.,  10144.,
      7876.,  8224.,  8572.,  8920.,  9418.,  9772.,  10126., 10480., 8128.,
      8488.,  8848.,  9208.,  9718.,  10084., 10450., 10816., 8884.,  9280.,
      9676.,  10072., 10618., 11020., 11422., 11824., 9136.,  9544.,  9952.,
      10360., 10918., 11332., 11746., 12160., 9388.,  9808.,  10228., 10648.,
      11218., 11644., 12070., 12496., 9640.,  10072., 10504., 10936., 11518.,
      11956., 12394., 12832., 9892.,  10336., 10780., 11224., 11818., 12268.,
      12718., 13168.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      137540., 140880., 144260., 147680., 168376., 172384., 176440., 180544.,
      200172., 204848., 209580., 214368., 173752., 177760., 181816., 185920.,
      146500., 149840., 153220., 156640., 204125., 208300., 212525., 216800.,
      247430., 252440., 257510., 262640., 291375., 297220., 303135., 309120.,
      250790., 255800., 260870., 266000., 209725., 213900., 218125., 222400.,
      275750., 280760., 285830., 290960., 331860., 337872., 343956., 350112.,
      388066., 395080., 402178., 409360., 331860., 337872., 343956., 350112.,
      275750., 280760., 285830., 290960., 209725., 213900., 218125., 222400.,
      250790., 255800., 260870., 266000., 291375., 297220., 303135., 309120.,
      247430., 252440., 257510., 262640., 204125., 208300., 212525., 216800.,
      146500., 149840., 153220., 156640., 173752., 177760., 181816., 185920.,
      200172., 204848., 209580., 214368., 168376., 172384., 176440., 180544.,
      137540., 140880., 144260., 147680.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1822.,  2008.,  2206.,  2416.,  2086.,  2296.,  2518.,  2752.,  2350.,
      2584.,  2830.,  3088.,  2614.,  2872.,  3142.,  3424.,  2878.,  3160.,
      3454.,  3760.,  3670.,  4024.,  4390.,  4768.,  3934.,  4312.,  4702.,
      5104.,  4198.,  4600.,  5014.,  5440.,  4462.,  4888.,  5326.,  5776.,
      4726.,  5176.,  5638.,  6112.,  5518.,  6040.,  6574.,  7120.,  5782.,
      6328.,  6886.,  7456.,  6046.,  6616.,  7198.,  7792.,  6310.,  6904.,
      7510.,  8128.,  6574.,  7192.,  7822.,  8464.,  7366.,  8056.,  8758.,
      9472.,  7630.,  8344.,  9070.,  9808.,  7894.,  8632.,  9382.,  10144.,
      8158.,  8920.,  9694.,  10480., 8422.,  9208.,  10006., 10816., 9214.,
      10072., 10942., 11824., 9478.,  10360., 11254., 12160., 9742.,  10648.,
      11566., 12496., 10006., 10936., 11878., 12832., 10270., 11224., 12190.,
      13168.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      274060., 275080., 280720., 281760., 287460., 288520., 294280., 295360.,
      335480., 336752., 343472., 344768., 351560., 352880., 359744., 361088.,
      398804., 400344., 408128., 409696., 417564., 419160., 427112., 428736.,
      346136., 347504., 354128., 355520., 362216., 363632., 370400., 371840.,
      291820., 293000., 298480., 299680., 305220., 306440., 312040., 313280.,
      406625., 408250., 414950., 416600., 423375., 425050., 431900., 433600.,
      492850., 494860., 502840., 504880., 512950., 515020., 523180., 525280.,
      580335., 582750., 591990., 594440., 603785., 606270., 615720., 618240.,
      499450., 501580., 509440., 511600., 519550., 521740., 529780., 532000.,
      417625., 419450., 425950., 427800., 434375., 436250., 442900., 444800.,
      549130., 551500., 559120., 561520., 569230., 571660., 579460., 581920.,
      660804., 663720., 672792., 675744., 684924., 687912., 697200., 700224.,
      772646., 776132., 786632., 790160., 800786., 804356., 815108., 818720.,
      660660., 663720., 672648., 675744., 684780., 687912., 697056., 700224.,
      548890., 551500., 558880., 561520., 568990., 571660., 579220., 581920.,
      417125., 419450., 425450., 427800., 433875., 436250., 442400., 444800.,
      498730., 501580., 508720., 511600., 518830., 521740., 529060., 532000.,
      579355., 582750., 591010., 594440., 602805., 606270., 614740., 618240.,
      491890., 494860., 501880., 504880., 511990., 515020., 522220., 525280.,
      405725., 408250., 414050., 416600., 422475., 425050., 431000., 433600.,
      290860., 293000., 297520., 299680., 304260., 306440., 311080., 313280.,
      344888., 347504., 352880., 355520., 360968., 363632., 369152., 371840.,
      397236., 400344., 406560., 409696., 415996., 419160., 425544., 428736.,
      334040., 336752., 342032., 344768., 350120., 352880., 358304., 361088.,
      272780., 275080., 279440., 281760., 286180., 288520., 293000., 295360.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3530.,  3644.,  3896.,  4016.,  4286.,  4412.,  4700.,  4832.,  4034.,
      4172.,  4448.,  4592.,  4886.,  5036.,  5348.,  5504.,  4538.,  4700.,
      5000.,  5168.,  5486.,  5660.,  5996.,  6176.,  5042.,  5228.,  5552.,
      5744.,  6086.,  6284.,  6644.,  6848.,  5546.,  5756.,  6104.,  6320.,
      6686.,  6908.,  7292.,  7520.,  7058.,  7340.,  7760.,  8048.,  8486.,
      8780.,  9236.,  9536.,  7562.,  7868.,  8312.,  8624.,  9086.,  9404.,
      9884.,  10208., 8066.,  8396.,  8864.,  9200.,  9686.,  10028., 10532.,
      10880., 8570.,  8924.,  9416.,  9776.,  10286., 10652., 11180., 11552.,
      9074.,  9452.,  9968.,  10352., 10886., 11276., 11828., 12224., 10586.,
      11036., 11624., 12080., 12686., 13148., 13772., 14240., 11090., 11564.,
      12176., 12656., 13286., 13772., 14420., 14912., 11594., 12092., 12728.,
      13232., 13886., 14396., 15068., 15584., 12098., 12620., 13280., 13808.,
      14486., 15020., 15716., 16256., 12602., 13148., 13832., 14384., 15086.,
      15644., 16364., 16928., 14114., 14732., 15488., 16112., 16886., 17516.,
      18308., 18944., 14618., 15260., 16040., 16688., 17486., 18140., 18956.,
      19616., 15122., 15788., 16592., 17264., 18086., 18764., 19604., 20288.,
      15626., 16316., 17144., 17840., 18686., 19388., 20252., 20960., 16130.,
      16844., 17696., 18416., 19286., 20012., 20900., 21632., 17642., 18428.,
      19352., 20144., 21086., 21884., 22844., 23648., 18146., 18956., 19904.,
      20720., 21686., 22508., 23492., 24320., 18650., 19484., 20456., 21296.,
      22286., 23132., 24140., 24992., 19154., 20012., 21008., 21872., 22886.,
      23756., 24788., 25664., 19658., 20540., 21560., 22448., 23486., 24380.,
      25436., 26336.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      547100.,  548120.,  549140.,  550160.,  560400.,  561440.,  562480.,
      563520.,  573860.,  574920.,  575980.,  577040.,  587480.,  588560.,
      589640.,  590720.,  669688.,  670960.,  672232.,  673504.,  685648.,
      686944.,  688240.,  689536.,  701800.,  703120.,  704440.,  705760.,
      718144.,  719488.,  720832.,  722176.,  796068.,  797608.,  799148.,
      800688.,  814688.,  816256.,  817824.,  819392.,  833532.,  835128.,
      836724.,  838320.,  852600.,  854224.,  855848.,  857472.,  690904.,
      692272.,  693640.,  695008.,  706864.,  708256.,  709648.,  711040.,
      723016.,  724432.,  725848.,  727264.,  739360.,  740800.,  742240.,
      743680.,  582460.,  583640.,  584820.,  586000.,  595760.,  596960.,
      598160.,  599360.,  609220.,  610440.,  611660.,  612880.,  622840.,
      624080.,  625320.,  626560.,  811625.,  813250.,  814875.,  816500.,
      828250.,  829900.,  831550.,  833200.,  845075.,  846750.,  848425.,
      850100.,  862100.,  863800.,  865500.,  867200.,  983690.,  985700.,
      987710.,  989720.,  1003640., 1005680., 1007720., 1009760., 1023830.,
      1025900., 1027970., 1030040., 1044260., 1046360., 1048460., 1050560.,
      1158255., 1160670., 1163085., 1165500., 1181530., 1183980., 1186430.,
      1188880., 1205085., 1207570., 1210055., 1212540., 1228920., 1231440.,
      1233960., 1236480., 996770.,  998900.,  1001030., 1003160., 1016720.,
      1018880., 1021040., 1023200., 1036910., 1039100., 1041290., 1043480.,
      1057340., 1059560., 1061780., 1064000., 833425.,  835250.,  837075.,
      838900.,  850050.,  851900.,  853750.,  855600.,  866875.,  868750.,
      870625.,  872500.,  883900.,  885800.,  887700.,  889600.,  1095890.,
      1098260., 1100630., 1103000., 1115840., 1118240., 1120640., 1123040.,
      1136030., 1138460., 1140890., 1143320., 1156460., 1158920., 1161380.,
      1163840., 1318692., 1321608., 1324524., 1327440., 1342632., 1345584.,
      1348536., 1351488., 1366860., 1369848., 1372836., 1375824., 1391376.,
      1394400., 1397424., 1400448., 1541806., 1545292., 1548778., 1552264.,
      1569736., 1573264., 1576792., 1580320., 1598002., 1601572., 1605142.,
      1608712., 1626604., 1630216., 1633828., 1637440., 1318260., 1321320.,
      1324380., 1327440., 1342200., 1345296., 1348392., 1351488., 1366428.,
      1369560., 1372692., 1375824., 1390944., 1394112., 1397280., 1400448.,
      1095170., 1097780., 1100390., 1103000., 1115120., 1117760., 1120400.,
      1123040., 1135310., 1137980., 1140650., 1143320., 1155740., 1158440.,
      1161140., 1163840., 831925.,  834250.,  836575.,  838900.,  848550.,
      850900.,  853250.,  855600.,  865375.,  867750.,  870125.,  872500.,
      882400.,  884800.,  887200.,  889600.,  994610.,  997460.,  1000310.,
      1003160., 1014560., 1017440., 1020320., 1023200., 1034750., 1037660.,
      1040570., 1043480., 1055180., 1058120., 1061060., 1064000., 1155315.,
      1158710., 1162105., 1165500., 1178590., 1182020., 1185450., 1188880.,
      1202145., 1205610., 1209075., 1212540., 1225980., 1229480., 1232980.,
      1236480., 980810.,  983780.,  986750.,  989720.,  1000760., 1003760.,
      1006760., 1009760., 1020950., 1023980., 1027010., 1030040., 1041380.,
      1044440., 1047500., 1050560., 808925.,  811450.,  813975.,  816500.,
      825550.,  828100.,  830650.,  833200.,  842375.,  844950.,  847525.,
      850100.,  859400.,  862000.,  864600.,  867200.,  579580.,  581720.,
      583860.,  586000.,  592880.,  595040.,  597200.,  599360.,  606340.,
      608520.,  610700.,  612880.,  619960.,  622160.,  624360.,  626560.,
      687160.,  689776.,  692392.,  695008.,  703120.,  705760.,  708400.,
      711040.,  719272.,  721936.,  724600.,  727264.,  735616.,  738304.,
      740992.,  743680.,  791364.,  794472.,  797580.,  800688.,  809984.,
      813120.,  816256.,  819392.,  828828.,  831992.,  835156.,  838320.,
      847896.,  851088.,  854280.,  857472.,  665368.,  668080.,  670792.,
      673504.,  681328.,  684064.,  686800.,  689536.,  697480.,  700240.,
      703000.,  705760.,  713824.,  716608.,  719392.,  722176.,  543260.,
      545560.,  547860.,  550160.,  556560.,  558880.,  561200.,  563520.,
      570020.,  572360.,  574700.,  577040.,  583640.,  586000.,  588360.,
      590720.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6946.,  7060.,  7174.,  7288.,  7672.,  7792.,  7912.,  8032.,  8446.,
      8572.,  8698.,  8824.,  9268.,  9400.,  9532.,  9664.,  7930.,  8068.,
      8206.,  8344.,  8752.,  8896.,  9040.,  9184.,  9622.,  9772.,  9922.,
      10072., 10540., 10696., 10852., 11008., 8914.,  9076.,  9238.,  9400.,
      9832.,  10000., 10168., 10336., 10798., 10972., 11146., 11320., 11812.,
      11992., 12172., 12352., 9898.,  10084., 10270., 10456., 10912., 11104.,
      11296., 11488., 11974., 12172., 12370., 12568., 13084., 13288., 13492.,
      13696., 10882., 11092., 11302., 11512., 11992., 12208., 12424., 12640.,
      13150., 13372., 13594., 13816., 14356., 14584., 14812., 15040., 13834.,
      14116., 14398., 14680., 15232., 15520., 15808., 16096., 16678., 16972.,
      17266., 17560., 18172., 18472., 18772., 19072., 14818., 15124., 15430.,
      15736., 16312., 16624., 16936., 17248., 17854., 18172., 18490., 18808.,
      19444., 19768., 20092., 20416., 15802., 16132., 16462., 16792., 17392.,
      17728., 18064., 18400., 19030., 19372., 19714., 20056., 20716., 21064.,
      21412., 21760., 16786., 17140., 17494., 17848., 18472., 18832., 19192.,
      19552., 20206., 20572., 20938., 21304., 21988., 22360., 22732., 23104.,
      17770., 18148., 18526., 18904., 19552., 19936., 20320., 20704., 21382.,
      21772., 22162., 22552., 23260., 23656., 24052., 24448., 20722., 21172.,
      21622., 22072., 22792., 23248., 23704., 24160., 24910., 25372., 25834.,
      26296., 27076., 27544., 28012., 28480., 21706., 22180., 22654., 23128.,
      23872., 24352., 24832., 25312., 26086., 26572., 27058., 27544., 28348.,
      28840., 29332., 29824., 22690., 23188., 23686., 24184., 24952., 25456.,
      25960., 26464., 27262., 27772., 28282., 28792., 29620., 30136., 30652.,
      31168., 23674., 24196., 24718., 25240., 26032., 26560., 27088., 27616.,
      28438., 28972., 29506., 30040., 30892., 31432., 31972., 32512., 24658.,
      25204., 25750., 26296., 27112., 27664., 28216., 28768., 29614., 30172.,
      30730., 31288., 32164., 32728., 33292., 33856., 27610., 28228., 28846.,
      29464., 30352., 30976., 31600., 32224., 33142., 33772., 34402., 35032.,
      35980., 36616., 37252., 37888., 28594., 29236., 29878., 30520., 31432.,
      32080., 32728., 33376., 34318., 34972., 35626., 36280., 37252., 37912.,
      38572., 39232., 29578., 30244., 30910., 31576., 32512., 33184., 33856.,
      34528., 35494., 36172., 36850., 37528., 38524., 39208., 39892., 40576.,
      30562., 31252., 31942., 32632., 33592., 34288., 34984., 35680., 36670.,
      37372., 38074., 38776., 39796., 40504., 41212., 41920., 31546., 32260.,
      32974., 33688., 34672., 35392., 36112., 36832., 37846., 38572., 39298.,
      40024., 41068., 41800., 42532., 43264., 34498., 35284., 36070., 36856.,
      37912., 38704., 39496., 40288., 41374., 42172., 42970., 43768., 44884.,
      45688., 46492., 47296., 35482., 36292., 37102., 37912., 38992., 39808.,
      40624., 41440., 42550., 43372., 44194., 45016., 46156., 46984., 47812.,
      48640., 36466., 37300., 38134., 38968., 40072., 40912., 41752., 42592.,
      43726., 44572., 45418., 46264., 47428., 48280., 49132., 49984., 37450.,
      38308., 39166., 40024., 41152., 42016., 42880., 43744., 44902., 45772.,
      46642., 47512., 48700., 49576., 50452., 51328., 38434., 39316., 40198.,
      41080., 42232., 43120., 44008., 44896., 46078., 46972., 47866., 48760.,
      49972., 50872., 51772., 52672.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14452., 17136., 19888., 17584., 15220., 21185., 24920., 28700., 25200.,
      21665., 28398., 33208., 38024., 33208., 28398., 21665., 25200., 28700.,
      24920., 21185., 15220., 17584., 19888., 17136., 14452.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      308.,  344.,  380.,  416.,  452.,  596.,  632.,  668.,  704.,
      740.,  884.,  920.,  956.,  992.,  1028., 1172., 1208., 1244.,
      1280., 1316., 1460., 1496., 1532., 1568., 1604.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28532., 28904., 33824., 34272., 39248., 39776., 34692., 35168., 30020.,
      30440., 41785., 42370., 49140., 49840., 56580., 57400., 49665., 50400.,
      42685., 43330., 55950., 56796., 65408., 66416., 74872., 76048., 65366.,
      66416., 55878., 56796., 42505., 43330., 49420., 50400., 56260., 57400.,
      48825., 49840., 41485., 42370., 29684., 30440., 34272., 35168., 38736.,
      39776., 33348., 34272., 28100., 28904.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      564.,  616.,  628.,  688.,  692.,  760.,  756.,  832.,  820.,  904.,
      1076., 1192., 1140., 1264., 1204., 1336., 1268., 1408., 1332., 1480.,
      1588., 1768., 1652., 1840., 1716., 1912., 1780., 1984., 1844., 2056.,
      2100., 2344., 2164., 2416., 2228., 2488., 2292., 2560., 2356., 2632.,
      2612., 2920., 2676., 2992., 2740., 3064., 2804., 3136., 2868., 3208.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      56692.,  57064.,  57436.,  57808.,  67200.,  67648.,  68096.,  68544.,
      77968.,  78496.,  79024.,  79552.,  68908.,  69384.,  69860.,  70336.,
      59620.,  60040.,  60460.,  60880.,  82985.,  83570.,  84155.,  84740.,
      97580.,  98280.,  98980.,  99680.,  112340., 113160., 113980., 114800.,
      98595.,  99330.,  100065., 100800., 84725.,  85370.,  86015.,  86660.,
      111054., 111900., 112746., 113592., 129808., 130816., 131824., 132832.,
      148568., 149744., 150920., 152096., 129682., 130732., 131782., 132832.,
      110838., 111756., 112674., 113592., 84185.,  85010.,  85835.,  86660.,
      97860.,  98840.,  99820.,  100800., 111380., 112520., 113660., 114800.,
      96635.,  97650.,  98665.,  99680.,  82085.,  82970.,  83855.,  84740.,
      58612.,  59368.,  60124.,  60880.,  67648.,  68544.,  69440.,  70336.,
      76432.,  77472.,  78512.,  79552.,  65772.,  66696.,  67620.,  68544.,
      55396.,  56200.,  57004.,  57808.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1076., 1128., 1180., 1232., 1196., 1256., 1316., 1376., 1316., 1384.,
      1452., 1520., 1436., 1512., 1588., 1664., 1556., 1640., 1724., 1808.,
      2036., 2152., 2268., 2384., 2156., 2280., 2404., 2528., 2276., 2408.,
      2540., 2672., 2396., 2536., 2676., 2816., 2516., 2664., 2812., 2960.,
      2996., 3176., 3356., 3536., 3116., 3304., 3492., 3680., 3236., 3432.,
      3628., 3824., 3356., 3560., 3764., 3968., 3476., 3688., 3900., 4112.,
      3956., 4200., 4444., 4688., 4076., 4328., 4580., 4832., 4196., 4456.,
      4716., 4976., 4316., 4584., 4852., 5120., 4436., 4712., 4988., 5264.,
      4916., 5224., 5532., 5840., 5036., 5352., 5668., 5984., 5156., 5480.,
      5804., 6128., 5276., 5608., 5940., 6272., 5396., 5736., 6076., 6416.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55480.,  57808.,  65828.,  68544.,  76448.,  79552.,  67620.,  70336.,
      58552.,  60880.,  81830.,  84740.,  96285.,  99680.,  110920., 114800.,
      97405.,  100800., 83750.,  86660.,  110100., 113592., 128758., 132832.,
      147440., 152096., 128758., 132832., 110100., 113592., 83750.,  86660.,
      97405.,  100800., 110920., 114800., 96285.,  99680.,  81830.,  84740.,
      58552.,  60880.,  67620.,  70336.,  76448.,  79552.,  65828.,  68544.,
      55480.,  57808.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1064., 1232., 1192., 1376., 1320., 1520., 1448., 1664., 1576., 1808.,
      2088., 2384., 2216., 2528., 2344., 2672., 2472., 2816., 2600., 2960.,
      3112., 3536., 3240., 3680., 3368., 3824., 3496., 3968., 3624., 4112.,
      4136., 4688., 4264., 4832., 4392., 4976., 4520., 5120., 4648., 5264.,
      5160., 5840., 5288., 5984., 5416., 6128., 5544., 6272., 5672., 6416.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      110240., 110960., 114872., 115616., 130788., 131656., 136192., 137088.,
      151872., 152896., 158048., 159104., 134316., 135240., 139720., 140672.,
      116288., 117104., 120920., 121760., 162520., 163660., 168310., 169480.,
      191205., 192570., 197960., 199360., 220240., 221840., 227960., 229600.,
      193375., 194810., 200130., 201600., 166240., 167500., 172030., 173320.,
      218544., 220200., 225492., 227184., 255542., 257516., 263648., 265664.,
      292576., 294880., 301840., 304192., 255458., 257516., 263564., 265664.,
      218400., 220200., 225348., 227184., 165880., 167500., 171670., 173320.,
      192885., 194810., 199640., 201600., 219600., 221840., 227320., 229600.,
      190575., 192570., 197330., 199360., 161920., 163660., 167710., 169480.,
      115616., 117104., 120248., 121760., 133476., 135240., 138880., 140672.,
      150848., 152896., 157024., 159104., 129836., 131656., 135240., 137088.,
      109376., 110960., 114008., 115616.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2032.,  2128.,  2360.,  2464.,  2272.,  2384.,  2632.,  2752.,  2512.,
      2640.,  2904.,  3040.,  2752.,  2896.,  3176.,  3328.,  2992.,  3152.,
      3448.,  3616.,  3952.,  4176.,  4536.,  4768.,  4192.,  4432.,  4808.,
      5056.,  4432.,  4688.,  5080.,  5344.,  4672.,  4944.,  5352.,  5632.,
      4912.,  5200.,  5624.,  5920.,  5872.,  6224.,  6712.,  7072.,  6112.,
      6480.,  6984.,  7360.,  6352.,  6736.,  7256.,  7648.,  6592.,  6992.,
      7528.,  7936.,  6832.,  7248.,  7800.,  8224.,  7792.,  8272.,  8888.,
      9376.,  8032.,  8528.,  9160.,  9664.,  8272.,  8784.,  9432.,  9952.,
      8512.,  9040.,  9704.,  10240., 8752.,  9296.,  9976.,  10528., 9712.,
      10320., 11064., 11680., 9952.,  10576., 11336., 11968., 10192., 10832.,
      11608., 12256., 10432., 11088., 11880., 12544., 10672., 11344., 12152.,
      12832.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      219760., 220480., 221200., 221920., 229000., 229744., 230488., 231232.,
      260708., 261576., 262444., 263312., 271488., 272384., 273280., 274176.,
      302720., 303744., 304768., 305792., 315040., 316096., 317152., 318208.,
      267708., 268632., 269556., 270480., 278488., 279440., 280392., 281344.,
      231760., 232576., 233392., 234208., 241000., 241840., 242680., 243520.,
      323900., 325040., 326180., 327320., 335450., 336620., 337790., 338960.,
      381045., 382410., 383775., 385140., 394520., 395920., 397320., 398720.,
      438880., 440480., 442080., 443680., 454280., 455920., 457560., 459200.,
      385315., 386750., 388185., 389620., 398790., 400260., 401730., 403200.,
      331220., 332480., 333740., 335000., 342770., 344060., 345350., 346640.,
      435432., 437088., 438744., 440400., 449292., 450984., 452676., 454368.,
      509110., 511084., 513058., 515032., 525280., 527296., 529312., 531328.,
      582848., 585152., 587456., 589760., 601328., 603680., 606032., 608384.,
      508858., 510916., 512974., 515032., 525028., 527128., 529228., 531328.,
      435000., 436800., 438600., 440400., 448860., 450696., 452532., 454368.,
      330140., 331760., 333380., 335000., 341690., 343340., 344990., 346640.,
      383845., 385770., 387695., 389620., 397320., 399280., 401240., 403200.,
      436960., 439200., 441440., 443680., 452360., 454640., 456920., 459200.,
      379155., 381150., 383145., 385140., 392630., 394660., 396690., 398720.,
      322100., 323840., 325580., 327320., 333650., 335420., 337190., 338960.,
      229744., 231232., 232720., 234208., 238984., 240496., 242008., 243520.,
      265188., 266952., 268716., 270480., 275968., 277760., 279552., 281344.,
      299648., 301696., 303744., 305792., 311968., 314048., 316128., 318208.,
      257852., 259672., 261492., 263312., 268632., 270480., 272328., 274176.,
      217168., 218752., 220336., 221920., 226408., 228016., 229624., 231232.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3968.,  4064.,  4160.,  4256.,  4616.,  4720.,  4824.,  4928.,  4432.,
      4544.,  4656.,  4768.,  5144.,  5264.,  5384.,  5504.,  4896.,  5024.,
      5152.,  5280.,  5672.,  5808.,  5944.,  6080.,  5360.,  5504.,  5648.,
      5792.,  6200.,  6352.,  6504.,  6656.,  5824.,  5984.,  6144.,  6304.,
      6728.,  6896.,  7064.,  7232.,  7680.,  7904.,  8128.,  8352.,  8840.,
      9072.,  9304.,  9536.,  8144.,  8384.,  8624.,  8864.,  9368.,  9616.,
      9864.,  10112., 8608.,  8864.,  9120.,  9376.,  9896.,  10160., 10424.,
      10688., 9072.,  9344.,  9616.,  9888.,  10424., 10704., 10984., 11264.,
      9536.,  9824.,  10112., 10400., 10952., 11248., 11544., 11840., 11392.,
      11744., 12096., 12448., 13064., 13424., 13784., 14144., 11856., 12224.,
      12592., 12960., 13592., 13968., 14344., 14720., 12320., 12704., 13088.,
      13472., 14120., 14512., 14904., 15296., 12784., 13184., 13584., 13984.,
      14648., 15056., 15464., 15872., 13248., 13664., 14080., 14496., 15176.,
      15600., 16024., 16448., 15104., 15584., 16064., 16544., 17288., 17776.,
      18264., 18752., 15568., 16064., 16560., 17056., 17816., 18320., 18824.,
      19328., 16032., 16544., 17056., 17568., 18344., 18864., 19384., 19904.,
      16496., 17024., 17552., 18080., 18872., 19408., 19944., 20480., 16960.,
      17504., 18048., 18592., 19400., 19952., 20504., 21056., 18816., 19424.,
      20032., 20640., 21512., 22128., 22744., 23360., 19280., 19904., 20528.,
      21152., 22040., 22672., 23304., 23936., 19744., 20384., 21024., 21664.,
      22568., 23216., 23864., 24512., 20208., 20864., 21520., 22176., 23096.,
      23760., 24424., 25088., 20672., 21344., 22016., 22688., 23624., 24304.,
      24984., 25664.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      217336., 221920., 226552., 231232., 257964., 263312., 268716., 274176.,
      299680., 305792., 311968., 318208., 265132., 270480., 275884., 281344.,
      229624., 234208., 238840., 243520., 321590., 327320., 333110., 338960.,
      378455., 385140., 391895., 398720., 436040., 443680., 451400., 459200.,
      382935., 389620., 396375., 403200., 329270., 335000., 340790., 346640.,
      433524., 440400., 447348., 454368., 507010., 515032., 523138., 531328.,
      580592., 589760., 599024., 608384., 507010., 515032., 523138., 531328.,
      433524., 440400., 447348., 454368., 329270., 335000., 340790., 346640.,
      382935., 389620., 396375., 403200., 436040., 443680., 451400., 459200.,
      378455., 385140., 391895., 398720., 321590., 327320., 333110., 338960.,
      229624., 234208., 238840., 243520., 265132., 270480., 275884., 281344.,
      299680., 305792., 311968., 318208., 257964., 263312., 268716., 274176.,
      217336., 221920., 226552., 231232.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3944.,  4256.,  4584.,  4928.,  4424.,  4768.,  5128.,  5504.,  4904.,
      5280.,  5672.,  6080.,  5384.,  5792.,  6216.,  6656.,  5864.,  6304.,
      6760.,  7232.,  7784.,  8352.,  8936.,  9536.,  8264.,  8864.,  9480.,
      10112., 8744.,  9376.,  10024., 10688., 9224.,  9888.,  10568., 11264.,
      9704.,  10400., 11112., 11840., 11624., 12448., 13288., 14144., 12104.,
      12960., 13832., 14720., 12584., 13472., 14376., 15296., 13064., 13984.,
      14920., 15872., 13544., 14496., 15464., 16448., 15464., 16544., 17640.,
      18752., 15944., 17056., 18184., 19328., 16424., 17568., 18728., 19904.,
      16904., 18080., 19272., 20480., 17384., 18592., 19816., 21056., 19304.,
      20640., 21992., 23360., 19784., 21152., 22536., 23936., 20264., 21664.,
      23080., 24512., 20744., 22176., 23624., 25088., 21224., 22688., 24168.,
      25664.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      433256.,  434672.,  442400.,  443840.,  451640.,  453104.,  460976.,
      462464.,  514220.,  515928.,  524888.,  526624.,  535668.,  537432.,
      546560.,  548352.,  597344.,  599360.,  609536.,  611584.,  621856.,
      623936.,  634304.,  636416.,  528444.,  530264.,  539112.,  540960.,
      549892.,  551768.,  560784.,  562688.,  457640.,  459248.,  466784.,
      468416.,  476024.,  477680.,  485360.,  487040.,  640930.,  643180.,
      652360.,  654640.,  663910.,  666220.,  675580.,  677920.,  754215.,
      756910.,  767550.,  770280.,  781025.,  783790.,  794640.,  797440.,
      868920.,  872080.,  884160.,  887360.,  899560.,  902800.,  915120.,
      918400.,  763035.,  765870.,  776370.,  779240.,  789845.,  792750.,
      803460.,  806400.,  656050.,  658540.,  667480.,  670000.,  679030.,
      681580.,  690700.,  693280.,  863772.,  867048.,  877488.,  880800.,
      891348.,  894696.,  905352.,  908736.,  1010114., 1014020., 1026116.,
      1030064., 1042286., 1046276., 1058624., 1062656., 1156624., 1161184.,
      1174912., 1179520., 1193392., 1198048., 1212064., 1216768., 1009946.,
      1014020., 1025948., 1030064., 1042118., 1046276., 1058456., 1062656.,
      863484.,  867048.,  877200.,  880800.,  891060.,  894696.,  905064.,
      908736.,  655330.,  658540.,  666760.,  670000.,  678310.,  681580.,
      689980.,  693280.,  762055.,  765870.,  775390.,  779240.,  788865.,
      792750.,  802480.,  806400.,  867640.,  872080.,  882880.,  887360.,
      898280.,  902800.,  913840.,  918400.,  752955.,  756910.,  766290.,
      770280.,  779765.,  783790.,  793380.,  797440.,  639730.,  643180.,
      651160.,  654640.,  662710.,  666220.,  674380.,  677920.,  456296.,
      459248.,  465440.,  468416.,  474680.,  477680.,  484016.,  487040.,
      526764.,  530264.,  537432.,  540960.,  548212.,  551768.,  559104.,
      562688.,  595296.,  599360.,  607488.,  611584.,  619808.,  623936.,
      632256.,  636416.,  512316.,  515928.,  522984.,  526624.,  533764.,
      537432.,  544656.,  548352.,  431528.,  434672.,  440672.,  443840.,
      449912.,  453104.,  459248.,  462464.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7704.,  7888.,  8320.,  8512.,  8968.,  9168.,  9648.,  9856.,  8632.,
      8848.,  9312.,  9536.,  10024., 10256., 10768., 11008., 9560.,  9808.,
      10304., 10560., 11080., 11344., 11888., 12160., 10488., 10768., 11296.,
      11584., 12136., 12432., 13008., 13312., 11416., 11728., 12288., 12608.,
      13192., 13520., 14128., 14464., 15128., 15568., 16256., 16704., 17416.,
      17872., 18608., 19072., 16056., 16528., 17248., 17728., 18472., 18960.,
      19728., 20224., 16984., 17488., 18240., 18752., 19528., 20048., 20848.,
      21376., 17912., 18448., 19232., 19776., 20584., 21136., 21968., 22528.,
      18840., 19408., 20224., 20800., 21640., 22224., 23088., 23680., 22552.,
      23248., 24192., 24896., 25864., 26576., 27568., 28288., 23480., 24208.,
      25184., 25920., 26920., 27664., 28688., 29440., 24408., 25168., 26176.,
      26944., 27976., 28752., 29808., 30592., 25336., 26128., 27168., 27968.,
      29032., 29840., 30928., 31744., 26264., 27088., 28160., 28992., 30088.,
      30928., 32048., 32896., 29976., 30928., 32128., 33088., 34312., 35280.,
      36528., 37504., 30904., 31888., 33120., 34112., 35368., 36368., 37648.,
      38656., 31832., 32848., 34112., 35136., 36424., 37456., 38768., 39808.,
      32760., 33808., 35104., 36160., 37480., 38544., 39888., 40960., 33688.,
      34768., 36096., 37184., 38536., 39632., 41008., 42112., 37400., 38608.,
      40064., 41280., 42760., 43984., 45488., 46720., 38328., 39568., 41056.,
      42304., 43816., 45072., 46608., 47872., 39256., 40528., 42048., 43328.,
      44872., 46160., 47728., 49024., 40184., 41488., 43040., 44352., 45928.,
      47248., 48848., 50176., 41112., 42448., 44032., 45376., 46984., 48336.,
      49968., 51328.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      865096.,  866512.,  867928.,  869344.,  883360.,  884800.,  886240.,
      887680.,  901816.,  903280.,  904744.,  906208.,  920464.,  921952.,
      923440.,  924928.,  1026732., 1028440., 1030148., 1031856., 1048040.,
      1049776., 1051512., 1053248., 1069572., 1071336., 1073100., 1074864.,
      1091328., 1093120., 1094912., 1096704., 1192672., 1194688., 1196704.,
      1198720., 1217024., 1219072., 1221120., 1223168., 1241632., 1243712.,
      1245792., 1247872., 1266496., 1268608., 1270720., 1272832., 1055068.,
      1056888., 1058708., 1060528., 1076376., 1078224., 1080072., 1081920.,
      1097908., 1099784., 1101660., 1103536., 1119664., 1121568., 1123472.,
      1125376., 913672.,  915280.,  916888.,  918496.,  931936.,  933568.,
      935200.,  936832.,  950392.,  952048.,  953704.,  955360.,  969040.,
      970720.,  972400.,  974080.,  1279610., 1281860., 1284110., 1286360.,
      1302440., 1304720., 1307000., 1309280., 1325510., 1327820., 1330130.,
      1332440., 1348820., 1351160., 1353500., 1355840., 1505735., 1508430.,
      1511125., 1513820., 1532370., 1535100., 1537830., 1540560., 1559285.,
      1562050., 1564815., 1567580., 1586480., 1589280., 1592080., 1594880.,
      1734680., 1737840., 1741000., 1744160., 1765120., 1768320., 1771520.,
      1774720., 1795880., 1799120., 1802360., 1805600., 1826960., 1830240.,
      1833520., 1836800., 1523235., 1526070., 1528905., 1531740., 1549870.,
      1552740., 1555610., 1558480., 1576785., 1579690., 1582595., 1585500.,
      1603980., 1606920., 1609860., 1612800., 1309610., 1312100., 1314590.,
      1317080., 1332440., 1334960., 1337480., 1340000., 1355510., 1358060.,
      1360610., 1363160., 1378820., 1381400., 1383980., 1386560., 1724268.,
      1727544., 1730820., 1734096., 1751664., 1754976., 1758288., 1761600.,
      1779348., 1782696., 1786044., 1789392., 1807320., 1810704., 1814088.,
      1817472., 2016322., 2020228., 2024134., 2028040., 2048284., 2052232.,
      2056180., 2060128., 2080582., 2084572., 2088562., 2092552., 2113216.,
      2117248., 2121280., 2125312., 2308688., 2313248., 2317808., 2322368.,
      2345216., 2349824., 2354432., 2359040., 2382128., 2386784., 2391440.,
      2396096., 2419424., 2424128., 2428832., 2433536., 2015818., 2019892.,
      2023966., 2028040., 2047780., 2051896., 2056012., 2060128., 2080078.,
      2084236., 2088394., 2092552., 2112712., 2116912., 2121112., 2125312.,
      1723404., 1726968., 1730532., 1734096., 1750800., 1754400., 1758000.,
      1761600., 1778484., 1782120., 1785756., 1789392., 1806456., 1810128.,
      1813800., 1817472., 1307450., 1310660., 1313870., 1317080., 1330280.,
      1333520., 1336760., 1340000., 1353350., 1356620., 1359890., 1363160.,
      1376660., 1379960., 1383260., 1386560., 1520295., 1524110., 1527925.,
      1531740., 1546930., 1550780., 1554630., 1558480., 1573845., 1577730.,
      1581615., 1585500., 1601040., 1604960., 1608880., 1612800., 1730840.,
      1735280., 1739720., 1744160., 1761280., 1765760., 1770240., 1774720.,
      1792040., 1796560., 1801080., 1805600., 1823120., 1827680., 1832240.,
      1836800., 1501955., 1505910., 1509865., 1513820., 1528590., 1532580.,
      1536570., 1540560., 1555505., 1559530., 1563555., 1567580., 1582700.,
      1586760., 1590820., 1594880., 1276010., 1279460., 1282910., 1286360.,
      1298840., 1302320., 1305800., 1309280., 1321910., 1325420., 1328930.,
      1332440., 1345220., 1348760., 1352300., 1355840., 909640.,  912592.,
      915544.,  918496.,  927904.,  930880.,  933856.,  936832.,  946360.,
      949360.,  952360.,  955360.,  965008.,  968032.,  971056.,  974080.,
      1050028., 1053528., 1057028., 1060528., 1071336., 1074864., 1078392.,
      1081920., 1092868., 1096424., 1099980., 1103536., 1114624., 1118208.,
      1121792., 1125376., 1186528., 1190592., 1194656., 1198720., 1210880.,
      1214976., 1219072., 1223168., 1235488., 1239616., 1243744., 1247872.,
      1260352., 1264512., 1268672., 1272832., 1021020., 1024632., 1028244.,
      1031856., 1042328., 1045968., 1049608., 1053248., 1063860., 1067528.,
      1071196., 1074864., 1085616., 1089312., 1093008., 1096704., 859912.,
      863056.,  866200.,  869344.,  878176.,  881344.,  884512.,  887680.,
      896632.,  899824.,  903016.,  906208.,  915280.,  918496.,  921712.,
      924928.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15224., 15408., 15592.,  15776., 16448., 16640.,  16832., 17024., 17736.,
      17936., 18136., 18336.,  19088., 19296., 19504.,  19712., 17048., 17264.,
      17480., 17696., 18400.,  18624., 18848., 19072.,  19816., 20048., 20280.,
      20512., 21296., 21536.,  21776., 22016., 18872.,  19120., 19368., 19616.,
      20352., 20608., 20864.,  21120., 21896., 22160.,  22424., 22688., 23504.,
      23776., 24048., 24320.,  20696., 20976., 21256.,  21536., 22304., 22592.,
      22880., 23168., 23976.,  24272., 24568., 24864.,  25712., 26016., 26320.,
      26624., 22520., 22832.,  23144., 23456., 24256.,  24576., 24896., 25216.,
      26056., 26384., 26712.,  27040., 27920., 28256.,  28592., 28928., 29816.,
      30256., 30696., 31136.,  32064., 32512., 32960.,  33408., 34376., 34832.,
      35288., 35744., 36752.,  37216., 37680., 38144.,  31640., 32112., 32584.,
      33056., 34016., 34496.,  34976., 35456., 36456.,  36944., 37432., 37920.,
      38960., 39456., 39952.,  40448., 33464., 33968.,  34472., 34976., 35968.,
      36480., 36992., 37504.,  38536., 39056., 39576.,  40096., 41168., 41696.,
      42224., 42752., 35288.,  35824., 36360., 36896.,  37920., 38464., 39008.,
      39552., 40616., 41168.,  41720., 42272., 43376.,  43936., 44496., 45056.,
      37112., 37680., 38248.,  38816., 39872., 40448.,  41024., 41600., 42696.,
      43280., 43864., 44448.,  45584., 46176., 46768.,  47360., 44408., 45104.,
      45800., 46496., 47680.,  48384., 49088., 49792.,  51016., 51728., 52440.,
      53152., 54416., 55136.,  55856., 56576., 46232.,  46960., 47688., 48416.,
      49632., 50368., 51104.,  51840., 53096., 53840.,  54584., 55328., 56624.,
      57376., 58128., 58880.,  48056., 48816., 49576.,  50336., 51584., 52352.,
      53120., 53888., 55176.,  55952., 56728., 57504.,  58832., 59616., 60400.,
      61184., 49880., 50672.,  51464., 52256., 53536.,  54336., 55136., 55936.,
      57256., 58064., 58872.,  59680., 61040., 61856.,  62672., 63488., 51704.,
      52528., 53352., 54176.,  55488., 56320., 57152.,  57984., 59336., 60176.,
      61016., 61856., 63248.,  64096., 64944., 65792.,  59000., 59952., 60904.,
      61856., 63296., 64256.,  65216., 66176., 67656.,  68624., 69592., 70560.,
      72080., 73056., 74032.,  75008., 60824., 61808.,  62792., 63776., 65248.,
      66240., 67232., 68224.,  69736., 70736., 71736.,  72736., 74288., 75296.,
      76304., 77312., 62648.,  63664., 64680., 65696.,  67200., 68224., 69248.,
      70272., 71816., 72848.,  73880., 74912., 76496.,  77536., 78576., 79616.,
      64472., 65520., 66568.,  67616., 69152., 70208.,  71264., 72320., 73896.,
      74960., 76024., 77088.,  78704., 79776., 80848.,  81920., 66296., 67376.,
      68456., 69536., 71104.,  72192., 73280., 74368.,  75976., 77072., 78168.,
      79264., 80912., 82016.,  83120., 84224., 73592.,  74800., 76008., 77216.,
      78912., 80128., 81344.,  82560., 84296., 85520.,  86744., 87968., 89744.,
      90976., 92208., 93440.,  75416., 76656., 77896.,  79136., 80864., 82112.,
      83360., 84608., 86376.,  87632., 88888., 90144.,  91952., 93216., 94480.,
      95744., 77240., 78512.,  79784., 81056., 82816.,  84096., 85376., 86656.,
      88456., 89744., 91032.,  92320., 94160., 95456.,  96752., 98048., 79064.,
      80368., 81672., 82976.,  84768., 86080., 87392.,  88704., 90536., 91856.,
      93176., 94496., 96368.,  97696., 99024., 100352., 80888., 82224., 83560.,
      84896., 86720., 88064.,  89408., 90752., 92616.,  93968., 95320., 96672.,
      98576., 99936., 101296., 102656.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9730.,  12350., 15035., 12650., 10210., 13260., 16710., 20202., 16890.,
      13548., 16982., 21280., 25585., 21280., 16982., 13548., 16890., 20202.,
      16710., 13260., 10210., 12650., 15035., 12350., 9730.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      207., 228., 249., 270., 291., 333., 354., 375., 396.,
      417., 459., 480., 501., 522., 543., 585., 606., 627.,
      648., 669., 711., 732., 753., 774., 795.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19170., 19460., 24325., 24700., 29605., 30070., 24900., 25300., 20090.,
      20420., 26100., 26520., 32880., 33420., 39738., 40404., 33210., 33780.,
      26628., 27096., 33390., 33964., 41825., 42560., 50267., 51170., 41790.,
      42560., 33334., 33964., 26532., 27096., 33060., 33780., 39522., 40404.,
      32670., 33420., 25908., 26520., 19890., 20420., 24625., 25300., 29245.,
      30070., 24000., 24700., 18890., 19460.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      369.,  414.,  405.,  456.,  441.,  498.,  477.,  540.,  513.,  582.,
      585.,  666.,  621.,  708.,  657.,  750.,  693.,  792.,  729.,  834.,
      801.,  918.,  837.,  960.,  873.,  1002., 909.,  1044., 945.,  1086.,
      1017., 1170., 1053., 1212., 1089., 1254., 1125., 1296., 1161., 1338.,
      1233., 1422., 1269., 1464., 1305., 1506., 1341., 1548., 1377., 1590.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38050., 38340., 38630., 38920., 48275.,  48650.,  49025.,  49400., 58745.,
      59210., 59675., 60140., 49400., 49800.,  50200.,  50600.,  39850., 40180.,
      40510., 40840., 51780., 52200., 52620.,  53040.,  65220.,  65760., 66300.,
      66840., 78810., 79476., 80142., 80808.,  65850.,  66420.,  66990., 67560.,
      52788., 53256., 53724., 54192., 66206.,  66780.,  67354.,  67928., 82915.,
      83650., 84385., 85120., 99631., 100534., 101437., 102340., 82810., 83580.,
      84350., 85120., 66038., 66668., 67298.,  67928.,  52500.,  53064., 53628.,
      54192., 65400., 66120., 66840., 67560.,  78162.,  79044.,  79926., 80808.,
      64590., 65340., 66090., 66840., 51204.,  51816.,  52428.,  53040., 39250.,
      39780., 40310., 40840., 48575., 49250.,  49925.,  50600.,  57665., 58490.,
      59315., 60140., 47300., 48000., 48700.,  49400.,  37210.,  37780., 38350.,
      38920.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      693.,  738.,  783.,  828.,  759.,  810.,  861.,  912.,  825.,  882.,
      939.,  996.,  891.,  954.,  1017., 1080., 957.,  1026., 1095., 1164.,
      1089., 1170., 1251., 1332., 1155., 1242., 1329., 1416., 1221., 1314.,
      1407., 1500., 1287., 1386., 1485., 1584., 1353., 1458., 1563., 1668.,
      1485., 1602., 1719., 1836., 1551., 1674., 1797., 1920., 1617., 1746.,
      1875., 2004., 1683., 1818., 1953., 2088., 1749., 1890., 2031., 2172.,
      1881., 2034., 2187., 2340., 1947., 2106., 2265., 2424., 2013., 2178.,
      2343., 2508., 2079., 2250., 2421., 2592., 2145., 2322., 2499., 2676.,
      2277., 2466., 2655., 2844., 2343., 2538., 2733., 2928., 2409., 2610.,
      2811., 3012., 2475., 2682., 2889., 3096., 2541., 2754., 2967., 3180.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37220., 38920., 47275., 49400., 57590., 60140., 48475., 50600.,  39140.,
      40840., 51000., 53040., 64290., 66840., 77748., 80808., 65010.,  67560.,
      52152., 54192., 65548., 67928., 82145., 85120., 98770., 102340., 82145.,
      85120., 65548., 67928., 52152., 54192., 65010., 67560., 77748.,  80808.,
      64290., 66840., 51000., 53040., 39140., 40840., 48475., 50600.,  57590.,
      60140., 47275., 49400., 37220., 38920.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      702.,  828.,  774.,  912.,  846.,  996.,  918.,  1080., 990.,  1164.,
      1134., 1332., 1206., 1416., 1278., 1500., 1350., 1584., 1422., 1668.,
      1566., 1836., 1638., 1920., 1710., 2004., 1782., 2088., 1854., 2172.,
      1998., 2340., 2070., 2424., 2142., 2508., 2214., 2592., 2286., 2676.,
      2430., 2844., 2502., 2928., 2574., 3012., 2646., 3096., 2718., 3180.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73880.,  74440.,  77260.,  77840.,  93825.,  94550.,  98050.,  98800.,
      114280., 115180., 119350., 120280., 96175.,  96950.,  100400., 101200.,
      77640.,  78280.,  81020.,  81680.,  101184., 102000., 105240., 106080.,
      127530., 128580., 132600., 133680., 154200., 155496., 160284., 161616.,
      128910., 130020., 133980., 135120., 103392., 104304., 107448., 108384.,
      129976., 131096., 134708., 135856., 162855., 164290., 168770., 170240.,
      195776., 197540., 202874., 204680., 162785., 164290., 168700., 170240.,
      129864., 131096., 134596., 135856., 103200., 104304., 107256., 108384.,
      128610., 130020., 133680., 135120., 153768., 155496., 159852., 161616.,
      127110., 128580., 132180., 133680., 100800., 102000., 104856., 106080.,
      77240.,  78280.,  80620.,  81680.,  95625.,  96950.,  99850.,  101200.,
      113560., 115180., 118630., 120280., 93175.,  94550.,  97400.,  98800.,
      73320.,  74440.,  76700.,  77840.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1320., 1404., 1566., 1656., 1452., 1548., 1722., 1824., 1584., 1692.,
      1878., 1992., 1716., 1836., 2034., 2160., 1848., 1980., 2190., 2328.,
      2112., 2268., 2502., 2664., 2244., 2412., 2658., 2832., 2376., 2556.,
      2814., 3000., 2508., 2700., 2970., 3168., 2640., 2844., 3126., 3336.,
      2904., 3132., 3438., 3672., 3036., 3276., 3594., 3840., 3168., 3420.,
      3750., 4008., 3300., 3564., 3906., 4176., 3432., 3708., 4062., 4344.,
      3696., 3996., 4374., 4680., 3828., 4140., 4530., 4848., 3960., 4284.,
      4686., 5016., 4092., 4428., 4842., 5184., 4224., 4572., 4998., 5352.,
      4488., 4860., 5310., 5688., 4620., 5004., 5466., 5856., 4752., 5148.,
      5622., 6024., 4884., 5292., 5778., 6192., 5016., 5436., 5934., 6360.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      147200., 147760., 148320., 148880., 153940., 154520., 155100., 155680.,
      186925., 187650., 188375., 189100., 195350., 196100., 196850., 197600.,
      227660., 228560., 229460., 230360., 237770., 238700., 239630., 240560.,
      191575., 192350., 193125., 193900., 200000., 200800., 201600., 202400.,
      154640., 155280., 155920., 156560., 161380., 162040., 162700., 163360.,
      201552., 202368., 203184., 204000., 209640., 210480., 211320., 212160.,
      254010., 255060., 256110., 257160., 264120., 265200., 266280., 267360.,
      307104., 308400., 309696., 310992., 319236., 320568., 321900., 323232.,
      256710., 257820., 258930., 260040., 266820., 267960., 269100., 270240.,
      205872., 206784., 207696., 208608., 213960., 214896., 215832., 216768.,
      258832., 259952., 261072., 262192., 268268., 269416., 270564., 271712.,
      324275., 325710., 327145., 328580., 336070., 337540., 339010., 340480.,
      389788., 391552., 393316., 395080., 403942., 405748., 407554., 409360.,
      324065., 325570., 327075., 328580., 335860., 337400., 338940., 340480.,
      258496., 259728., 260960., 262192., 267932., 269192., 270452., 271712.,
      205296., 206400., 207504., 208608., 213384., 214512., 215640., 216768.,
      255810., 257220., 258630., 260040., 265920., 267360., 268800., 270240.,
      305808., 307536., 309264., 310992., 317940., 319704., 321468., 323232.,
      252750., 254220., 255690., 257160., 262860., 264360., 265860., 267360.,
      200400., 201600., 202800., 204000., 208488., 209712., 210936., 212160.,
      153440., 154480., 155520., 156560., 160180., 161240., 162300., 163360.,
      189925., 191250., 192575., 193900., 198350., 199700., 201050., 202400.,
      225500., 227120., 228740., 230360., 235610., 237260., 238910., 240560.,
      184975., 186350., 187725., 189100., 193400., 194800., 196200., 197600.,
      145520., 146640., 147760., 148880., 152260., 153400., 154540., 155680.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2556.,  2640.,  2724.,  2808.,  3042.,  3132.,  3222.,  3312.,  2808.,
      2904.,  3000.,  3096.,  3342.,  3444.,  3546.,  3648.,  3060.,  3168.,
      3276.,  3384.,  3642.,  3756.,  3870.,  3984.,  3312.,  3432.,  3552.,
      3672.,  3942.,  4068.,  4194.,  4320.,  3564.,  3696.,  3828.,  3960.,
      4242.,  4380.,  4518.,  4656.,  4068.,  4224.,  4380.,  4536.,  4842.,
      5004.,  5166.,  5328.,  4320.,  4488.,  4656.,  4824.,  5142.,  5316.,
      5490.,  5664.,  4572.,  4752.,  4932.,  5112.,  5442.,  5628.,  5814.,
      6000.,  4824.,  5016.,  5208.,  5400.,  5742.,  5940.,  6138.,  6336.,
      5076.,  5280.,  5484.,  5688.,  6042.,  6252.,  6462.,  6672.,  5580.,
      5808.,  6036.,  6264.,  6642.,  6876.,  7110.,  7344.,  5832.,  6072.,
      6312.,  6552.,  6942.,  7188.,  7434.,  7680.,  6084.,  6336.,  6588.,
      6840.,  7242.,  7500.,  7758.,  8016.,  6336.,  6600.,  6864.,  7128.,
      7542.,  7812.,  8082.,  8352.,  6588.,  6864.,  7140.,  7416.,  7842.,
      8124.,  8406.,  8688.,  7092.,  7392.,  7692.,  7992.,  8442.,  8748.,
      9054.,  9360.,  7344.,  7656.,  7968.,  8280.,  8742.,  9060.,  9378.,
      9696.,  7596.,  7920.,  8244.,  8568.,  9042.,  9372.,  9702.,  10032.,
      7848.,  8184.,  8520.,  8856.,  9342.,  9684.,  10026., 10368., 8100.,
      8448.,  8796.,  9144.,  9642.,  9996.,  10350., 10704., 8604.,  8976.,
      9348.,  9720.,  10242., 10620., 10998., 11376., 8856.,  9240.,  9624.,
      10008., 10542., 10932., 11322., 11712., 9108.,  9504.,  9900.,  10296.,
      10842., 11244., 11646., 12048., 9360.,  9768.,  10176., 10584., 11142.,
      11556., 11970., 12384., 9612.,  10032., 10452., 10872., 11442., 11868.,
      12294., 12720.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145540., 148880., 152260., 155680., 184925., 189100., 193325., 197600.,
      225350., 230360., 235430., 240560., 189725., 193900., 198125., 202400.,
      153220., 156560., 159940., 163360., 199992., 204000., 208056., 212160.,
      252150., 257160., 262230., 267360., 304980., 310992., 317076., 323232.,
      255030., 260040., 265110., 270240., 204600., 208608., 212664., 216768.,
      257516., 262192., 266924., 271712., 322735., 328580., 334495., 340480.,
      388066., 395080., 402178., 409360., 322735., 328580., 334495., 340480.,
      257516., 262192., 266924., 271712., 204600., 208608., 212664., 216768.,
      255030., 260040., 265110., 270240., 304980., 310992., 317076., 323232.,
      252150., 257160., 262230., 267360., 199992., 204000., 208056., 212160.,
      153220., 156560., 159940., 163360., 189725., 193900., 198125., 202400.,
      225350., 230360., 235430., 240560., 184925., 189100., 193325., 197600.,
      145540., 148880., 152260., 155680.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2574.,  2808.,  3054.,  3312.,  2838.,  3096.,  3366.,  3648.,  3102.,
      3384.,  3678.,  3984.,  3366.,  3672.,  3990.,  4320.,  3630.,  3960.,
      4302.,  4656.,  4158.,  4536.,  4926.,  5328.,  4422.,  4824.,  5238.,
      5664.,  4686.,  5112.,  5550.,  6000.,  4950.,  5400.,  5862.,  6336.,
      5214.,  5688.,  6174.,  6672.,  5742.,  6264.,  6798.,  7344.,  6006.,
      6552.,  7110.,  7680.,  6270.,  6840.,  7422.,  8016.,  6534.,  7128.,
      7734.,  8352.,  6798.,  7416.,  8046.,  8688.,  7326.,  7992.,  8670.,
      9360.,  7590.,  8280.,  8982.,  9696.,  7854.,  8568.,  9294.,  10032.,
      8118.,  8856.,  9606.,  10368., 8382.,  9144.,  9918.,  10704., 8910.,
      9720.,  10542., 11376., 9174.,  10008., 10854., 11712., 9438.,  10296.,
      11166., 12048., 9702.,  10584., 11478., 12384., 9966.,  10872., 11790.,
      12720.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      289980., 291080., 296640., 297760., 303380., 304520., 310200., 311360.,
      368425., 369850., 376750., 378200., 385175., 386650., 393700., 395200.,
      448930., 450700., 458920., 460720., 469030., 470860., 479260., 481120.,
      377925., 379450., 386250., 387800., 394675., 396250., 403200., 404800.,
      305180., 306440., 311840., 313120., 318580., 319880., 325400., 326720.,
      398376., 399984., 406368., 408000., 414456., 416112., 422640., 424320.,
      502230., 504300., 512220., 514320., 522330., 524460., 532560., 534720.,
      607404., 609960., 619392., 621984., 631524., 634152., 643800., 646464.,
      507870., 510060., 517860., 520080., 527970., 530220., 538200., 540480.,
      407400., 409200., 415392., 417216., 423480., 425328., 431664., 433536.,
      512820., 515032., 522144., 524384., 531580., 533848., 541128., 543424.,
      642635., 645470., 654290., 657160., 666085., 668990., 678020., 680960.,
      772646., 776132., 786632., 790160., 800786., 804356., 815108., 818720.,
      642495., 645470., 654150., 657160., 665945., 668990., 677880., 680960.,
      512596., 515032., 521920., 524384., 531356., 533848., 540904., 543424.,
      407016., 409200., 415008., 417216., 423096., 425328., 431280., 433536.,
      507270., 510060., 517260., 520080., 527370., 530220., 537600., 540480.,
      606540., 609960., 618528., 621984., 630660., 634152., 642936., 646464.,
      501390., 504300., 511380., 514320., 521490., 524460., 531720., 534720.,
      397608., 399984., 405600., 408000., 413688., 416112., 421872., 424320.,
      304380., 306440., 311040., 313120., 317780., 319880., 324600., 326720.,
      376825., 379450., 385150., 387800., 393575., 396250., 402100., 404800.,
      447490., 450700., 457480., 460720., 467590., 470860., 477820., 481120.,
      367125., 369850., 375450., 378200., 383875., 386650., 392400., 395200.,
      288860., 291080., 295520., 297760., 302260., 304520., 309080., 311360.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4986.,  5148.,  5448.,  5616.,  5934.,  6108.,  6444.,  6624.,  5490.,
      5676.,  6000.,  6192.,  6534.,  6732.,  7092.,  7296.,  5994.,  6204.,
      6552.,  6768.,  7134.,  7356.,  7740.,  7968.,  6498.,  6732.,  7104.,
      7344.,  7734.,  7980.,  8388.,  8640.,  7002.,  7260.,  7656.,  7920.,
      8334.,  8604.,  9036.,  9312.,  8010.,  8316.,  8760.,  9072.,  9534.,
      9852.,  10332., 10656., 8514.,  8844.,  9312.,  9648.,  10134., 10476.,
      10980., 11328., 9018.,  9372.,  9864.,  10224., 10734., 11100., 11628.,
      12000., 9522.,  9900.,  10416., 10800., 11334., 11724., 12276., 12672.,
      10026., 10428., 10968., 11376., 11934., 12348., 12924., 13344., 11034.,
      11484., 12072., 12528., 13134., 13596., 14220., 14688., 11538., 12012.,
      12624., 13104., 13734., 14220., 14868., 15360., 12042., 12540., 13176.,
      13680., 14334., 14844., 15516., 16032., 12546., 13068., 13728., 14256.,
      14934., 15468., 16164., 16704., 13050., 13596., 14280., 14832., 15534.,
      16092., 16812., 17376., 14058., 14652., 15384., 15984., 16734., 17340.,
      18108., 18720., 14562., 15180., 15936., 16560., 17334., 17964., 18756.,
      19392., 15066., 15708., 16488., 17136., 17934., 18588., 19404., 20064.,
      15570., 16236., 17040., 17712., 18534., 19212., 20052., 20736., 16074.,
      16764., 17592., 18288., 19134., 19836., 20700., 21408., 17082., 17820.,
      18696., 19440., 20334., 21084., 21996., 22752., 17586., 18348., 19248.,
      20016., 20934., 21708., 22644., 23424., 18090., 18876., 19800., 20592.,
      21534., 22332., 23292., 24096., 18594., 19404., 20352., 21168., 22134.,
      22956., 23940., 24768., 19098., 19932., 20904., 21744., 22734., 23580.,
      24588., 25440.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      578860.,  579960.,  581060.,  582160.,  592160.,  593280.,  594400.,
      595520.,  605620.,  606760.,  607900.,  609040.,  619240.,  620400.,
      621560.,  622720.,  735425.,  736850.,  738275.,  739700.,  752050.,
      753500.,  754950.,  756400.,  768875.,  770350.,  771825.,  773300.,
      785900.,  787400.,  788900.,  790400.,  896090.,  897860.,  899630.,
      901400.,  916040.,  917840.,  919640.,  921440.,  936230.,  938060.,
      939890.,  941720.,  956660.,  958520.,  960380.,  962240.,  754325.,
      755850.,  757375.,  758900.,  770950.,  772500.,  774050.,  775600.,
      787775.,  789350.,  790925.,  792500.,  804800.,  806400.,  808000.,
      809600.,  609100.,  610360.,  611620.,  612880.,  622400.,  623680.,
      624960.,  626240.,  635860.,  637160.,  638460.,  639760.,  649480.,
      650800.,  652120.,  653440.,  795144.,  796752.,  798360.,  799968.,
      811104.,  812736.,  814368.,  816000.,  827256.,  828912.,  830568.,
      832224.,  843600.,  845280.,  846960.,  848640.,  1002390., 1004460.,
      1006530., 1008600., 1022340., 1024440., 1026540., 1028640., 1042530.,
      1044660., 1046790., 1048920., 1062960., 1065120., 1067280., 1069440.,
      1212252., 1214808., 1217364., 1219920., 1236192., 1238784., 1241376.,
      1243968., 1260420., 1263048., 1265676., 1268304., 1284936., 1287600.,
      1290264., 1292928., 1013550., 1015740., 1017930., 1020120., 1033500.,
      1035720., 1037940., 1040160., 1053690., 1055940., 1058190., 1060440.,
      1074120., 1076400., 1078680., 1080960., 813000.,  814800.,  816600.,
      818400.,  828960.,  830784.,  832608.,  834432.,  845112.,  846960.,
      848808.,  850656.,  861456.,  863328.,  865200.,  867072.,  1023428.,
      1025640., 1027852., 1030064., 1042048., 1044288., 1046528., 1048768.,
      1060892., 1063160., 1065428., 1067696., 1079960., 1082256., 1084552.,
      1086848., 1282435., 1285270., 1288105., 1290940., 1305710., 1308580.,
      1311450., 1314320., 1329265., 1332170., 1335075., 1337980., 1353100.,
      1356040., 1358980., 1361920., 1541806., 1545292., 1548778., 1552264.,
      1569736., 1573264., 1576792., 1580320., 1598002., 1601572., 1605142.,
      1608712., 1626604., 1630216., 1633828., 1637440., 1282015., 1284990.,
      1287965., 1290940., 1305290., 1308300., 1311310., 1314320., 1328845.,
      1331890., 1334935., 1337980., 1352680., 1355760., 1358840., 1361920.,
      1022756., 1025192., 1027628., 1030064., 1041376., 1043840., 1046304.,
      1048768., 1060220., 1062712., 1065204., 1067696., 1079288., 1081808.,
      1084328., 1086848., 811848.,  814032.,  816216.,  818400.,  827808.,
      830016.,  832224.,  834432.,  843960.,  846192.,  848424.,  850656.,
      860304.,  862560.,  864816.,  867072.,  1011750., 1014540., 1017330.,
      1020120., 1031700., 1034520., 1037340., 1040160., 1051890., 1054740.,
      1057590., 1060440., 1072320., 1075200., 1078080., 1080960., 1209660.,
      1213080., 1216500., 1219920., 1233600., 1237056., 1240512., 1243968.,
      1257828., 1261320., 1264812., 1268304., 1282344., 1285872., 1289400.,
      1292928., 999870.,  1002780., 1005690., 1008600., 1019820., 1022760.,
      1025700., 1028640., 1040010., 1042980., 1045950., 1048920., 1060440.,
      1063440., 1066440., 1069440., 792840.,  795216.,  797592.,  799968.,
      808800.,  811200.,  813600.,  816000.,  824952.,  827376.,  829800.,
      832224.,  841296.,  843744.,  846192.,  848640.,  606700.,  608760.,
      610820.,  612880.,  620000.,  622080.,  624160.,  626240.,  633460.,
      635560.,  637660.,  639760.,  647080.,  649200.,  651320.,  653440.,
      751025.,  753650.,  756275.,  758900.,  767650.,  770300.,  772950.,
      775600.,  784475.,  787150.,  789825.,  792500.,  801500.,  804200.,
      806900.,  809600.,  891770.,  894980.,  898190.,  901400.,  911720.,
      914960.,  918200.,  921440.,  931910.,  935180.,  938450.,  941720.,
      952340.,  955640.,  958940.,  962240.,  731525.,  734250.,  736975.,
      739700.,  748150.,  750900.,  753650.,  756400.,  764975.,  767750.,
      770525.,  773300.,  782000.,  784800.,  787600.,  790400.,  575500.,
      577720.,  579940.,  582160.,  588800.,  591040.,  593280.,  595520.,
      602260.,  604520.,  606780.,  609040.,  615880.,  618160.,  620440.,
      622720.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9810.,  9972.,  10134., 10296., 10728., 10896., 11064., 11232., 11694.,
      11868., 12042., 12216., 12708., 12888., 13068., 13248., 10794., 10980.,
      11166., 11352., 11808., 12000., 12192., 12384., 12870., 13068., 13266.,
      13464., 13980., 14184., 14388., 14592., 11778., 11988., 12198., 12408.,
      12888., 13104., 13320., 13536., 14046., 14268., 14490., 14712., 15252.,
      15480., 15708., 15936., 12762., 12996., 13230., 13464., 13968., 14208.,
      14448., 14688., 15222., 15468., 15714., 15960., 16524., 16776., 17028.,
      17280., 13746., 14004., 14262., 14520., 15048., 15312., 15576., 15840.,
      16398., 16668., 16938., 17208., 17796., 18072., 18348., 18624., 15714.,
      16020., 16326., 16632., 17208., 17520., 17832., 18144., 18750., 19068.,
      19386., 19704., 20340., 20664., 20988., 21312., 16698., 17028., 17358.,
      17688., 18288., 18624., 18960., 19296., 19926., 20268., 20610., 20952.,
      21612., 21960., 22308., 22656., 17682., 18036., 18390., 18744., 19368.,
      19728., 20088., 20448., 21102., 21468., 21834., 22200., 22884., 23256.,
      23628., 24000., 18666., 19044., 19422., 19800., 20448., 20832., 21216.,
      21600., 22278., 22668., 23058., 23448., 24156., 24552., 24948., 25344.,
      19650., 20052., 20454., 20856., 21528., 21936., 22344., 22752., 23454.,
      23868., 24282., 24696., 25428., 25848., 26268., 26688., 21618., 22068.,
      22518., 22968., 23688., 24144., 24600., 25056., 25806., 26268., 26730.,
      27192., 27972., 28440., 28908., 29376., 22602., 23076., 23550., 24024.,
      24768., 25248., 25728., 26208., 26982., 27468., 27954., 28440., 29244.,
      29736., 30228., 30720., 23586., 24084., 24582., 25080., 25848., 26352.,
      26856., 27360., 28158., 28668., 29178., 29688., 30516., 31032., 31548.,
      32064., 24570., 25092., 25614., 26136., 26928., 27456., 27984., 28512.,
      29334., 29868., 30402., 30936., 31788., 32328., 32868., 33408., 25554.,
      26100., 26646., 27192., 28008., 28560., 29112., 29664., 30510., 31068.,
      31626., 32184., 33060., 33624., 34188., 34752., 27522., 28116., 28710.,
      29304., 30168., 30768., 31368., 31968., 32862., 33468., 34074., 34680.,
      35604., 36216., 36828., 37440., 28506., 29124., 29742., 30360., 31248.,
      31872., 32496., 33120., 34038., 34668., 35298., 35928., 36876., 37512.,
      38148., 38784., 29490., 30132., 30774., 31416., 32328., 32976., 33624.,
      34272., 35214., 35868., 36522., 37176., 38148., 38808., 39468., 40128.,
      30474., 31140., 31806., 32472., 33408., 34080., 34752., 35424., 36390.,
      37068., 37746., 38424., 39420., 40104., 40788., 41472., 31458., 32148.,
      32838., 33528., 34488., 35184., 35880., 36576., 37566., 38268., 38970.,
      39672., 40692., 41400., 42108., 42816., 33426., 34164., 34902., 35640.,
      36648., 37392., 38136., 38880., 39918., 40668., 41418., 42168., 43236.,
      43992., 44748., 45504., 34410., 35172., 35934., 36696., 37728., 38496.,
      39264., 40032., 41094., 41868., 42642., 43416., 44508., 45288., 46068.,
      46848., 35394., 36180., 36966., 37752., 38808., 39600., 40392., 41184.,
      42270., 43068., 43866., 44664., 45780., 46584., 47388., 48192., 36378.,
      37188., 37998., 38808., 39888., 40704., 41520., 42336., 43446., 44268.,
      45090., 45912., 47052., 47880., 48708., 49536., 37362., 38196., 39030.,
      39864., 40968., 41808., 42648., 43488., 44622., 45468., 46314., 47160.,
      48324., 49176., 50028., 50880.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16525., 20090., 23730., 20510., 17225., 22490., 27174., 31906., 27426.,
      22910., 28770., 34594., 40425., 34594., 28770., 22910., 27426., 31906.,
      27174., 22490., 17225., 20510., 23730., 20090., 16525.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      537.,  582.,  627.,  672.,  717.,  852.,  897.,  942.,  987.,
      1032., 1167., 1212., 1257., 1302., 1347., 1482., 1527., 1572.,
      1617., 1662., 1797., 1842., 1887., 1932., 1977.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32625., 33050., 39655., 40180., 46830., 47460., 40465., 41020., 33975.,
      34450., 44365., 44980., 53592., 54348., 62909., 63812., 54060., 54852.,
      45145., 45820., 56700., 57540., 68159., 69188., 79625., 80850., 68117.,
      69188., 56630., 57540., 44995., 45820., 53844., 54852., 62615., 63812.,
      53304., 54348., 44095., 44980., 33675., 34450., 40075., 41020., 46340.,
      47460., 39205., 40180., 32225., 33050.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      993.,  1074., 1074., 1164., 1155., 1254., 1236., 1344., 1317., 1434.,
      1560., 1704., 1641., 1794., 1722., 1884., 1803., 1974., 1884., 2064.,
      2127., 2334., 2208., 2424., 2289., 2514., 2370., 2604., 2451., 2694.,
      2694., 2964., 2775., 3054., 2856., 3144., 2937., 3234., 3018., 3324.,
      3261., 3594., 3342., 3684., 3423., 3774., 3504., 3864., 3585., 3954.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      64825.,  65250.,  65675.,  66100.,  78785.,  79310.,  79835.,  80360.,
      93030.,  93660.,  94290.,  94920.,  80375.,  80930.,  81485.,  82040.,
      67475.,  67950.,  68425.,  68900.,  88115.,  88730.,  89345.,  89960.,
      106428., 107184., 107940., 108696., 124915., 125818., 126721., 127624.,
      107328., 108120., 108912., 109704., 89615.,  90290.,  90965.,  91640.,
      112560., 113400., 114240., 115080., 135289., 136318., 137347., 138376.,
      158025., 159250., 160475., 161700., 135163., 136234., 137305., 138376.,
      112350., 113260., 114170., 115080., 89165.,  89990.,  90815.,  91640.,
      106680., 107688., 108696., 109704., 124033., 125230., 126427., 127624.,
      105564., 106608., 107652., 108696., 87305.,  88190.,  89075.,  89960.,
      66575.,  67350.,  68125.,  68900.,  79205.,  80150.,  81095.,  82040.,
      91560.,  92680.,  93800.,  94920.,  77435.,  78410.,  79385.,  80360.,
      63625.,  64450.,  65275.,  66100.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1905., 1986., 2067., 2148., 2058., 2148., 2238., 2328., 2211., 2310.,
      2409., 2508., 2364., 2472., 2580., 2688., 2517., 2634., 2751., 2868.,
      2976., 3120., 3264., 3408., 3129., 3282., 3435., 3588., 3282., 3444.,
      3606., 3768., 3435., 3606., 3777., 3948., 3588., 3768., 3948., 4128.,
      4047., 4254., 4461., 4668., 4200., 4416., 4632., 4848., 4353., 4578.,
      4803., 5028., 4506., 4740., 4974., 5208., 4659., 4902., 5145., 5388.,
      5118., 5388., 5658., 5928., 5271., 5550., 5829., 6108., 5424., 5712.,
      6000., 6288., 5577., 5874., 6171., 6468., 5730., 6036., 6342., 6648.,
      6189., 6522., 6855., 7188., 6342., 6684., 7026., 7368., 6495., 6846.,
      7197., 7548., 6648., 7008., 7368., 7728., 6801., 7170., 7539., 7908.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63625.,  66100.,  77390.,  80360.,  91455.,  94920.,  79070.,  82040.,
      66425.,  68900.,  86990.,  89960.,  105132., 108696., 123466., 127624.,
      106140., 109704., 88670.,  91640.,  111615., 115080., 134218., 138376.,
      156849., 161700., 134218., 138376., 111615., 115080., 88670.,  91640.,
      106140., 109704., 123466., 127624., 105132., 108696., 86990.,  89960.,
      66425.,  68900.,  79070.,  82040.,  91455.,  94920.,  77390.,  80360.,
      63625.,  66100.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1905., 2148., 2067., 2328., 2229., 2508., 2391., 2688., 2553., 2868.,
      3039., 3408., 3201., 3588., 3363., 3768., 3525., 3948., 3687., 4128.,
      4173., 4668., 4335., 4848., 4497., 5028., 4659., 5208., 4821., 5388.,
      5307., 5928., 5469., 6108., 5631., 6288., 5793., 6468., 5955., 6648.,
      6441., 7188., 6603., 7368., 6765., 7548., 6927., 7728., 7089., 7908.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      126425., 127250., 131350., 132200., 153760., 154780., 159670., 160720.,
      181685., 182910., 188580., 189840., 157060., 158140., 162970., 164080.,
      131925., 132850., 136850., 137800., 172780., 173980., 178690., 179920.,
      208788., 210264., 215880., 217392., 245168., 246932., 253442., 255248.,
      210732., 212280., 217824., 219408., 176020., 177340., 181930., 183280.,
      221585., 223230., 228480., 230160., 266420., 268436., 274694., 276752.,
      311297., 313698., 320950., 323400., 266336., 268436., 274610., 276752.,
      221445., 223230., 228340., 230160., 175720., 177340., 181630., 183280.,
      210300., 212280., 217392., 219408., 244580., 246932., 252854., 255248.,
      208212., 210264., 215304., 217392., 172240., 173980., 178150., 179920.,
      131325., 132850., 136250., 137800., 156280., 158140., 162190., 164080.,
      180705., 182910., 187600., 189840., 152860., 154780., 158770., 160720.,
      125625., 127250., 130550., 132200.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3657.,  3810.,  4134.,  4296.,  3963.,  4134.,  4476.,  4656.,  4269.,
      4458.,  4818.,  5016.,  4575.,  4782.,  5160.,  5376.,  4881.,  5106.,
      5502.,  5736.,  5799.,  6078.,  6528.,  6816.,  6105.,  6402.,  6870.,
      7176.,  6411.,  6726.,  7212.,  7536.,  6717.,  7050.,  7554.,  7896.,
      7023.,  7374.,  7896.,  8256.,  7941.,  8346.,  8922.,  9336.,  8247.,
      8670.,  9264.,  9696.,  8553.,  8994.,  9606.,  10056., 8859.,  9318.,
      9948.,  10416., 9165.,  9642.,  10290., 10776., 10083., 10614., 11316.,
      11856., 10389., 10938., 11658., 12216., 10695., 11262., 12000., 12576.,
      11001., 11586., 12342., 12936., 11307., 11910., 12684., 13296., 12225.,
      12882., 13710., 14376., 12531., 13206., 14052., 14736., 12837., 13530.,
      14394., 15096., 13143., 13854., 14736., 15456., 13449., 14178., 15078.,
      15816.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      252025., 252850., 253675., 254500., 261850., 262700., 263550., 264400.,
      306500., 307520., 308540., 309560., 318290., 319340., 320390., 321440.,
      362145., 363370., 364595., 365820., 375900., 377160., 378420., 379680.,
      313040., 314120., 315200., 316280., 324830., 325940., 327050., 328160.,
      262925., 263850., 264775., 265700., 272750., 273700., 274650., 275600.,
      344360., 345560., 346760., 347960., 356150., 357380., 358610., 359840.,
      416100., 417576., 419052., 420528., 430248., 431760., 433272., 434784.,
      488572., 490336., 492100., 493864., 505078., 506884., 508690., 510496.,
      419916., 421464., 423012., 424560., 434064., 435648., 437232., 438816.,
      350720., 352040., 353360., 354680., 362510., 363860., 365210., 366560.,
      441525., 443170., 444815., 446460., 455280., 456960., 458640., 460320.,
      530824., 532840., 534856., 536872., 547330., 549388., 551446., 553504.,
      620193., 622594., 624995., 627396., 639450., 641900., 644350., 646800.,
      530572., 532672., 534772., 536872., 547078., 549220., 551362., 553504.,
      441105., 442890., 444675., 446460., 454860., 456680., 458500., 460320.,
      349820., 351440., 353060., 354680., 361610., 363260., 364910., 366560.,
      418620., 420600., 422580., 424560., 432768., 434784., 436800., 438816.,
      486808., 489160., 491512., 493864., 503314., 505708., 508102., 510496.,
      414372., 416424., 418476., 420528., 428520., 430608., 432696., 434784.,
      342740., 344480., 346220., 347960., 354530., 356300., 358070., 359840.,
      261125., 262650., 264175., 265700., 270950., 272500., 274050., 275600.,
      310700., 312560., 314420., 316280., 322490., 324380., 326270., 328160.,
      359205., 361410., 363615., 365820., 372960., 375200., 377440., 379680.,
      303800., 305720., 307640., 309560., 315590., 317540., 319490., 321440.,
      249625., 251250., 252875., 254500., 259450., 261100., 262750., 264400.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7161.,  7314.,  7467.,  7620.,  8106.,  8268.,  8430.,  8592.,  7755.,
      7926.,  8097.,  8268.,  8772.,  8952.,  9132.,  9312.,  8349.,  8538.,
      8727.,  8916.,  9438.,  9636.,  9834.,  10032., 8943.,  9150.,  9357.,
      9564.,  10104., 10320., 10536., 10752., 9537.,  9762.,  9987.,  10212.,
      10770., 11004., 11238., 11472., 11319., 11598., 11877., 12156., 12768.,
      13056., 13344., 13632., 11913., 12210., 12507., 12804., 13434., 13740.,
      14046., 14352., 12507., 12822., 13137., 13452., 14100., 14424., 14748.,
      15072., 13101., 13434., 13767., 14100., 14766., 15108., 15450., 15792.,
      13695., 14046., 14397., 14748., 15432., 15792., 16152., 16512., 15477.,
      15882., 16287., 16692., 17430., 17844., 18258., 18672., 16071., 16494.,
      16917., 17340., 18096., 18528., 18960., 19392., 16665., 17106., 17547.,
      17988., 18762., 19212., 19662., 20112., 17259., 17718., 18177., 18636.,
      19428., 19896., 20364., 20832., 17853., 18330., 18807., 19284., 20094.,
      20580., 21066., 21552., 19635., 20166., 20697., 21228., 22092., 22632.,
      23172., 23712., 20229., 20778., 21327., 21876., 22758., 23316., 23874.,
      24432., 20823., 21390., 21957., 22524., 23424., 24000., 24576., 25152.,
      21417., 22002., 22587., 23172., 24090., 24684., 25278., 25872., 22011.,
      22614., 23217., 23820., 24756., 25368., 25980., 26592., 23793., 24450.,
      25107., 25764., 26754., 27420., 28086., 28752., 24387., 25062., 25737.,
      26412., 27420., 28104., 28788., 29472., 24981., 25674., 26367., 27060.,
      28086., 28788., 29490., 30192., 25575., 26286., 26997., 27708., 28752.,
      29472., 30192., 30912., 26169., 26898., 27627., 28356., 29418., 30156.,
      30894., 31632.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      249625., 254500., 259425., 264400., 303710., 309560., 315470., 321440.,
      358995., 365820., 372715., 379680., 310430., 316280., 322190., 328160.,
      260825., 265700., 270625., 275600., 342110., 347960., 353870., 359840.,
      413508., 420528., 427620., 434784., 485674., 493864., 502138., 510496.,
      417540., 424560., 431652., 438816., 348830., 354680., 360590., 366560.,
      439635., 446460., 453355., 460320., 528682., 536872., 545146., 553504.,
      617841., 627396., 637049., 646800., 528682., 536872., 545146., 553504.,
      439635., 446460., 453355., 460320., 348830., 354680., 360590., 366560.,
      417540., 424560., 431652., 438816., 485674., 493864., 502138., 510496.,
      413508., 420528., 427620., 434784., 342110., 347960., 353870., 359840.,
      260825., 265700., 270625., 275600., 310430., 316280., 322190., 328160.,
      358995., 365820., 372715., 379680., 303710., 309560., 315470., 321440.,
      249625., 254500., 259425., 264400.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7161.,  7620.,  8097.,  8592.,  7773.,  8268.,  8781.,  9312.,  8385.,
      8916.,  9465.,  10032., 8997.,  9564.,  10149., 10752., 9609.,  10212.,
      10833., 11472., 11445., 12156., 12885., 13632., 12057., 12804., 13569.,
      14352., 12669., 13452., 14253., 15072., 13281., 14100., 14937., 15792.,
      13893., 14748., 15621., 16512., 15729., 16692., 17673., 18672., 16341.,
      17340., 18357., 19392., 16953., 17988., 19041., 20112., 17565., 18636.,
      19725., 20832., 18177., 19284., 20409., 21552., 20013., 21228., 22461.,
      23712., 20625., 21876., 23145., 24432., 21237., 22524., 23829., 25152.,
      21849., 23172., 24513., 25872., 22461., 23820., 25197., 26592., 24297.,
      25764., 27249., 28752., 24909., 26412., 27933., 29472., 25521., 27060.,
      28617., 30192., 26133., 27708., 29301., 30912., 26745., 28356., 29985.,
      31632.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      497625.,  499250.,  507350.,  509000.,  517175.,  518850.,  527100.,
      528800.,  605410.,  607420.,  617080.,  619120.,  628870.,  630940.,
      640780.,  642880.,  715575.,  717990.,  729190.,  731640.,  742945.,
      745430.,  756840.,  759360.,  618730.,  620860.,  630400.,  632560.,
      642190.,  644380.,  654100.,  656320.,  519825.,  521650.,  529550.,
      531400.,  539375.,  541250.,  549300.,  551200.,  681850.,  684220.,
      693520.,  695920.,  705310.,  707740.,  717220.,  719680.,  824100.,
      827016.,  838104.,  841056.,  852252.,  855240.,  866544.,  869568.,
      967862.,  971348.,  984200.,  987728.,  1000706., 1004276., 1017380.,
      1020992., 832020.,  835080.,  846024.,  849120.,  860172.,  863304.,
      874464.,  877632.,  695050.,  697660.,  706720.,  709360.,  718510.,
      721180.,  730420.,  733120.,  876015.,  879270.,  889630.,  892920.,
      903385.,  906710.,  917280.,  920640.,  1053374., 1057364., 1069712.,
      1073744., 1086218., 1090292., 1102892., 1107008., 1230929., 1235682.,
      1249990., 1254792., 1269247., 1274098., 1288700., 1293600., 1053206.,
      1057364., 1069544., 1073744., 1086050., 1090292., 1102724., 1107008.,
      875735.,  879270.,  889350.,  892920.,  903105.,  906710.,  917000.,
      920640.,  694450.,  697660.,  706120.,  709360.,  717910.,  721180.,
      729820.,  733120.,  831156.,  835080.,  845160.,  849120.,  859308.,
      863304.,  873600.,  877632.,  966686.,  971348.,  983024.,  987728.,
      999530.,  1004276., 1016204., 1020992., 822948.,  827016.,  836952.,
      841056.,  851100.,  855240.,  865392.,  869568.,  680770.,  684220.,
      692440.,  695920.,  704230.,  707740.,  716140.,  719680.,  518625.,
      521650.,  528350.,  531400.,  538175.,  541250.,  548100.,  551200.,
      617170.,  620860.,  628840.,  632560.,  640630.,  644380.,  652540.,
      656320.,  713615.,  717990.,  727230.,  731640.,  740985.,  745430.,
      754880.,  759360.,  603610.,  607420.,  615280.,  619120.,  627070.,
      630940.,  638980.,  642880.,  496025.,  499250.,  505750.,  509000.,
      515575.,  518850.,  525500.,  528800.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14025., 14322., 14934., 15240., 15879., 16194., 16860., 17184., 15213.,
      15546., 16194., 16536., 17211., 17562., 18264., 18624., 16401., 16770.,
      17454., 17832., 18543., 18930., 19668., 20064., 17589., 17994., 18714.,
      19128., 19875., 20298., 21072., 21504., 18777., 19218., 19974., 20424.,
      21207., 21666., 22476., 22944., 22341., 22890., 23754., 24312., 25203.,
      25770., 26688., 27264., 23529., 24114., 25014., 25608., 26535., 27138.,
      28092., 28704., 24717., 25338., 26274., 26904., 27867., 28506., 29496.,
      30144., 25905., 26562., 27534., 28200., 29199., 29874., 30900., 31584.,
      27093., 27786., 28794., 29496., 30531., 31242., 32304., 33024., 30657.,
      31458., 32574., 33384., 34527., 35346., 36516., 37344., 31845., 32682.,
      33834., 34680., 35859., 36714., 37920., 38784., 33033., 33906., 35094.,
      35976., 37191., 38082., 39324., 40224., 34221., 35130., 36354., 37272.,
      38523., 39450., 40728., 41664., 35409., 36354., 37614., 38568., 39855.,
      40818., 42132., 43104., 38973., 40026., 41394., 42456., 43851., 44922.,
      46344., 47424., 40161., 41250., 42654., 43752., 45183., 46290., 47748.,
      48864., 41349., 42474., 43914., 45048., 46515., 47658., 49152., 50304.,
      42537., 43698., 45174., 46344., 47847., 49026., 50556., 51744., 43725.,
      44922., 46434., 47640., 49179., 50394., 51960., 53184., 47289., 48594.,
      50214., 51528., 53175., 54498., 56172., 57504., 48477., 49818., 51474.,
      52824., 54507., 55866., 57576., 58944., 49665., 51042., 52734., 54120.,
      55839., 57234., 58980., 60384., 50853., 52266., 53994., 55416., 57171.,
      58602., 60384., 61824., 52041., 53490., 55254., 56712., 58503., 59970.,
      61788., 63264.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      993625.,  995250.,  996875.,  998500.,  1013050., 1014700., 1016350.,
      1018000., 1032675., 1034350., 1036025., 1037700., 1052500., 1054200.,
      1055900., 1057600., 1208810., 1210820., 1212830., 1214840., 1232120.,
      1234160., 1236200., 1238240., 1255670., 1257740., 1259810., 1261880.,
      1279460., 1281560., 1283660., 1285760., 1428735., 1431150., 1433565.,
      1435980., 1455930., 1458380., 1460830., 1463280., 1483405., 1485890.,
      1488375., 1490860., 1511160., 1513680., 1516200., 1518720., 1235330.,
      1237460., 1239590., 1241720., 1258640., 1260800., 1262960., 1265120.,
      1282190., 1284380., 1286570., 1288760., 1305980., 1308200., 1310420.,
      1312640., 1037825., 1039650., 1041475., 1043300., 1057250., 1059100.,
      1060950., 1062800., 1076875., 1078750., 1080625., 1082500., 1096700.,
      1098600., 1100500., 1102400., 1361330., 1363700., 1366070., 1368440.,
      1384640., 1387040., 1389440., 1391840., 1408190., 1410620., 1413050.,
      1415480., 1431980., 1434440., 1436900., 1439360., 1645284., 1648200.,
      1651116., 1654032., 1673256., 1676208., 1679160., 1682112., 1701516.,
      1704504., 1707492., 1710480., 1730064., 1733088., 1736112., 1739136.,
      1932238., 1935724., 1939210., 1942696., 1964872., 1968400., 1971928.,
      1975456., 1997842., 2001412., 2004982., 2008552., 2031148., 2034760.,
      2038372., 2041984., 1660980., 1664040., 1667100., 1670160., 1688952.,
      1692048., 1695144., 1698240., 1717212., 1720344., 1723476., 1726608.,
      1745760., 1748928., 1752096., 1755264., 1387490., 1390100., 1392710.,
      1395320., 1410800., 1413440., 1416080., 1418720., 1434350., 1437020.,
      1439690., 1442360., 1458140., 1460840., 1463540., 1466240., 1748775.,
      1752030., 1755285., 1758540., 1775970., 1779260., 1782550., 1785840.,
      1803445., 1806770., 1810095., 1813420., 1831200., 1834560., 1837920.,
      1841280., 2102758., 2106748., 2110738., 2114728., 2135392., 2139424.,
      2143456., 2147488., 2168362., 2172436., 2176510., 2180584., 2201668.,
      2205784., 2209900., 2214016., 2457105., 2461858., 2466611., 2471364.,
      2495178., 2499980., 2504782., 2509584., 2533643., 2538494., 2543345.,
      2548196., 2572500., 2577400., 2582300., 2587200., 2102254., 2106412.,
      2110570., 2114728., 2134888., 2139088., 2143288., 2147488., 2167858.,
      2172100., 2176342., 2180584., 2201164., 2205448., 2209732., 2214016.,
      1747935., 1751470., 1755005., 1758540., 1775130., 1778700., 1782270.,
      1785840., 1802605., 1806210., 1809815., 1813420., 1830360., 1834000.,
      1837640., 1841280., 1385690., 1388900., 1392110., 1395320., 1409000.,
      1412240., 1415480., 1418720., 1432550., 1435820., 1439090., 1442360.,
      1456340., 1459640., 1462940., 1466240., 1658388., 1662312., 1666236.,
      1670160., 1686360., 1690320., 1694280., 1698240., 1714620., 1718616.,
      1722612., 1726608., 1743168., 1747200., 1751232., 1755264., 1928710.,
      1933372., 1938034., 1942696., 1961344., 1966048., 1970752., 1975456.,
      1994314., 1999060., 2003806., 2008552., 2027620., 2032408., 2037196.,
      2041984., 1641828., 1645896., 1649964., 1654032., 1669800., 1673904.,
      1678008., 1682112., 1698060., 1702200., 1706340., 1710480., 1726608.,
      1730784., 1734960., 1739136., 1358090., 1361540., 1364990., 1368440.,
      1381400., 1384880., 1388360., 1391840., 1404950., 1408460., 1411970.,
      1415480., 1428740., 1432280., 1435820., 1439360., 1034225., 1037250.,
      1040275., 1043300., 1053650., 1056700., 1059750., 1062800., 1073275.,
      1076350., 1079425., 1082500., 1093100., 1096200., 1099300., 1102400.,
      1230650., 1234340., 1238030., 1241720., 1253960., 1257680., 1261400.,
      1265120., 1277510., 1281260., 1285010., 1288760., 1301300., 1305080.,
      1308860., 1312640., 1422855., 1427230., 1431605., 1435980., 1450050.,
      1454460., 1458870., 1463280., 1477525., 1481970., 1486415., 1490860.,
      1505280., 1509760., 1514240., 1518720., 1203410., 1207220., 1211030.,
      1214840., 1226720., 1230560., 1234400., 1238240., 1250270., 1254140.,
      1258010., 1261880., 1274060., 1277960., 1281860., 1285760., 988825.,
      992050.,  995275.,  998500.,  1008250., 1011500., 1014750., 1018000.,
      1027875., 1031150., 1034425., 1037700., 1047700., 1051000., 1054300.,
      1057600.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27753.,  28050.,  28347.,  28644.,  29562.,  29868.,  30174.,  30480.,
      31443.,  31758.,  32073.,  32388.,  33396.,  33720.,  34044.,  34368.,
      30093.,  30426.,  30759.,  31092.,  32046.,  32388.,  32730.,  33072.,
      34071.,  34422.,  34773.,  35124.,  36168.,  36528.,  36888.,  37248.,
      32433.,  32802.,  33171.,  33540.,  34530.,  34908.,  35286.,  35664.,
      36699.,  37086.,  37473.,  37860.,  38940.,  39336.,  39732.,  40128.,
      34773.,  35178.,  35583.,  35988.,  37014.,  37428.,  37842.,  38256.,
      39327.,  39750.,  40173.,  40596.,  41712.,  42144.,  42576.,  43008.,
      37113.,  37554.,  37995.,  38436.,  39498.,  39948.,  40398.,  40848.,
      41955.,  42414.,  42873.,  43332.,  44484.,  44952.,  45420.,  45888.,
      44133.,  44682.,  45231.,  45780.,  46950.,  47508.,  48066.,  48624.,
      49839.,  50406.,  50973.,  51540.,  52800.,  53376.,  53952.,  54528.,
      46473.,  47058.,  47643.,  48228.,  49434.,  50028.,  50622.,  51216.,
      52467.,  53070.,  53673.,  54276.,  55572.,  56184.,  56796.,  57408.,
      48813.,  49434.,  50055.,  50676.,  51918.,  52548.,  53178.,  53808.,
      55095.,  55734.,  56373.,  57012.,  58344.,  58992.,  59640.,  60288.,
      51153.,  51810.,  52467.,  53124.,  54402.,  55068.,  55734.,  56400.,
      57723.,  58398.,  59073.,  59748.,  61116.,  61800.,  62484.,  63168.,
      53493.,  54186.,  54879.,  55572.,  56886.,  57588.,  58290.,  58992.,
      60351.,  61062.,  61773.,  62484.,  63888.,  64608.,  65328.,  66048.,
      60513.,  61314.,  62115.,  62916.,  64338.,  65148.,  65958.,  66768.,
      68235.,  69054.,  69873.,  70692.,  72204.,  73032.,  73860.,  74688.,
      62853.,  63690.,  64527.,  65364.,  66822.,  67668.,  68514.,  69360.,
      70863.,  71718.,  72573.,  73428.,  74976.,  75840.,  76704.,  77568.,
      65193.,  66066.,  66939.,  67812.,  69306.,  70188.,  71070.,  71952.,
      73491.,  74382.,  75273.,  76164.,  77748.,  78648.,  79548.,  80448.,
      67533.,  68442.,  69351.,  70260.,  71790.,  72708.,  73626.,  74544.,
      76119.,  77046.,  77973.,  78900.,  80520.,  81456.,  82392.,  83328.,
      69873.,  70818.,  71763.,  72708.,  74274.,  75228.,  76182.,  77136.,
      78747.,  79710.,  80673.,  81636.,  83292.,  84264.,  85236.,  86208.,
      76893.,  77946.,  78999.,  80052.,  81726.,  82788.,  83850.,  84912.,
      86631.,  87702.,  88773.,  89844.,  91608.,  92688.,  93768.,  94848.,
      79233.,  80322.,  81411.,  82500.,  84210.,  85308.,  86406.,  87504.,
      89259.,  90366.,  91473.,  92580.,  94380.,  95496.,  96612.,  97728.,
      81573.,  82698.,  83823.,  84948.,  86694.,  87828.,  88962.,  90096.,
      91887.,  93030.,  94173.,  95316.,  97152.,  98304.,  99456.,  100608.,
      83913.,  85074.,  86235.,  87396.,  89178.,  90348.,  91518.,  92688.,
      94515.,  95694.,  96873.,  98052.,  99924.,  101112., 102300., 103488.,
      86253.,  87450.,  88647.,  89844.,  91662.,  92868.,  94074.,  95280.,
      97143.,  98358.,  99573.,  100788., 102696., 103920., 105144., 106368.,
      93273.,  94578.,  95883.,  97188.,  99114.,  100428., 101742., 103056.,
      105027., 106350., 107673., 108996., 111012., 112344., 113676., 115008.,
      95613.,  96954.,  98295.,  99636.,  101598., 102948., 104298., 105648.,
      107655., 109014., 110373., 111732., 113784., 115152., 116520., 117888.,
      97953.,  99330.,  100707., 102084., 104082., 105468., 106854., 108240.,
      110283., 111678., 113073., 114468., 116556., 117960., 119364., 120768.,
      100293., 101706., 103119., 104532., 106566., 107988., 109410., 110832.,
      112911., 114342., 115773., 117204., 119328., 120768., 122208., 123648.,
      102633., 104082., 105531., 106980., 109050., 110508., 111966., 113424.,
      115539., 117006., 118473., 119940., 122100., 123576., 125052., 126528.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25865., 30520., 35260., 31080., 26825., 35166., 41272., 47432., 41608.,
      35742., 44947., 52528., 60116., 52528., 44947., 35742., 41608., 47432.,
      41272., 35166., 26825., 31080., 35260., 30520., 25865.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1090., 1168., 1246., 1324., 1402., 1714., 1792., 1870., 1948.,
      2026., 2338., 2416., 2494., 2572., 2650., 2962., 3040., 3118.,
      3196., 3274., 3586., 3664., 3742., 3820., 3898.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      51145.,  51730.,  60340.,  61040.,  69700., 70520., 61425.,  62160.,
      53005.,  53650.,  69486.,  70332.,  81536., 82544., 93688.,  94864.,
      82166.,  83216.,  70566.,  71484.,  88739., 89894., 103684., 105056.,
      118636., 120232., 103635., 105056., 88655., 89894., 70350.,  71484.,
      81872.,  83216.,  93304.,  94864.,  81158., 82544., 69126.,  70332.,
      52585.,  53650.,  60900.,  62160.,  69060., 70520., 59745.,  61040.,
      50605.,  51730.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2054., 2180., 2198., 2336., 2342., 2492., 2486., 2648., 2630., 2804.,
      3206., 3428., 3350., 3584., 3494., 3740., 3638., 3896., 3782., 4052.,
      4358., 4676., 4502., 4832., 4646., 4988., 4790., 5144., 4934., 5300.,
      5510., 5924., 5654., 6080., 5798., 6236., 5942., 6392., 6086., 6548.,
      6662., 7172., 6806., 7328., 6950., 7484., 7094., 7640., 7238., 7796.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      101705., 102290., 102875., 103460., 119980., 120680., 121380., 122080.,
      138580., 139400., 140220., 141040., 122115., 122850., 123585., 124320.,
      105365., 106010., 106655., 107300., 138126., 138972., 139818., 140664.,
      162064., 163072., 164080., 165088., 186200., 187376., 188552., 189728.,
      163282., 164332., 165382., 166432., 140214., 141132., 142050., 142968.,
      176323., 177478., 178633., 179788., 205996., 207368., 208740., 210112.,
      235676., 237272., 238868., 240464., 205849., 207270., 208691., 210112.,
      176071., 177310., 178549., 179788., 139566., 140700., 141834., 142968.,
      162400., 163744., 165088., 166432., 185048., 186608., 188168., 189728.,
      160930., 162316., 163702., 165088., 137046., 138252., 139458., 140664.,
      104105., 105170., 106235., 107300., 120540., 121800., 123060., 124320.,
      136660., 138120., 139580., 141040., 118195., 119490., 120785., 122080.,
      100085., 101210., 102335., 103460.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3982.,  4108.,  4234.,  4360.,  4258.,  4396.,  4534.,  4672.,  4534.,
      4684.,  4834.,  4984.,  4810.,  4972.,  5134.,  5296.,  5086.,  5260.,
      5434.,  5608.,  6190.,  6412.,  6634.,  6856.,  6466.,  6700.,  6934.,
      7168.,  6742.,  6988.,  7234.,  7480.,  7018.,  7276.,  7534.,  7792.,
      7294.,  7564.,  7834.,  8104.,  8398.,  8716.,  9034.,  9352.,  8674.,
      9004.,  9334.,  9664.,  8950.,  9292.,  9634.,  9976.,  9226.,  9580.,
      9934.,  10288., 9502.,  9868.,  10234., 10600., 10606., 11020., 11434.,
      11848., 10882., 11308., 11734., 12160., 11158., 11596., 12034., 12472.,
      11434., 11884., 12334., 12784., 11710., 12172., 12634., 13096., 12814.,
      13324., 13834., 14344., 13090., 13612., 14134., 14656., 13366., 13900.,
      14434., 14968., 13642., 14188., 14734., 15280., 13918., 14476., 15034.,
      15592.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      100070., 103460., 118125., 122080., 136520., 141040., 120365., 124320.,
      103910., 107300., 136596., 140664., 160342., 165088., 184304., 189728.,
      161686., 166432., 138900., 142968., 175042., 179788., 204575., 210112.,
      234136., 240464., 204575., 210112., 175042., 179788., 138900., 142968.,
      161686., 166432., 184304., 189728., 160342., 165088., 136596., 140664.,
      103910., 107300., 120365., 124320., 136520., 141040., 118125., 122080.,
      100070., 103460.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3964.,  4360.,  4252.,  4672.,  4540.,  4984.,  4828.,  5296.,  5116.,
      5608.,  6268.,  6856.,  6556.,  7168.,  6844.,  7480.,  7132.,  7792.,
      7420.,  8104.,  8572.,  9352.,  8860.,  9664.,  9148.,  9976.,  9436.,
      10288., 9724.,  10600., 10876., 11848., 11164., 12160., 11452., 12472.,
      11740., 12784., 12028., 13096., 13180., 14344., 13468., 14656., 13756.,
      14968., 14044., 15280., 14332., 15592.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      199000., 200140., 205750., 206920., 234885., 236250., 242760., 244160.,
      271440., 273040., 280440., 282080., 239295., 240730., 247170., 248640.,
      206560., 207820., 213310., 214600., 271536., 273192., 279636., 281328.,
      318710., 320684., 328160., 330176., 366304., 368608., 377104., 379456.,
      321314., 323372., 330764., 332864., 276000., 277800., 284100., 285936.,
      347816., 350084., 357266., 359576., 406455., 409150., 417480., 420224.,
      465136., 468272., 477736., 480928., 406357., 409150., 417382., 420224.,
      347648., 350084., 357098., 359576., 275568., 277800., 283668., 285936.,
      320726., 323372., 330176., 332864., 365536., 368608., 376336., 379456.,
      317954., 320684., 327404., 330176., 270816., 273192., 278916., 281328.,
      205720., 207820., 212470., 214600., 238245., 240730., 246120., 248640.,
      270160., 273040., 279160., 282080., 233695., 236250., 241570., 244160.,
      197920., 200140., 204670., 206920.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7688.,  7928.,  8468.,  8720.,  8240.,  8504.,  9068.,  9344.,  8792.,
      9080.,  9668.,  9968.,  9344.,  9656.,  10268., 10592., 9896.,  10232.,
      10868., 11216., 12104., 12536., 13268., 13712., 12656., 13112., 13868.,
      14336., 13208., 13688., 14468., 14960., 13760., 14264., 15068., 15584.,
      14312., 14840., 15668., 16208., 16520., 17144., 18068., 18704., 17072.,
      17720., 18668., 19328., 17624., 18296., 19268., 19952., 18176., 18872.,
      19868., 20576., 18728., 19448., 20468., 21200., 20936., 21752., 22868.,
      23696., 21488., 22328., 23468., 24320., 22040., 22904., 24068., 24944.,
      22592., 23480., 24668., 25568., 23144., 24056., 25268., 26192., 25352.,
      26360., 27668., 28688., 25904., 26936., 28268., 29312., 26456., 27512.,
      28868., 29936., 27008., 28088., 29468., 30560., 27560., 28664., 30068.,
      31184.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      396860., 398000., 399140., 400280., 410330., 411500., 412670., 413840.,
      468405., 469770., 471135., 472500., 484120., 485520., 486920., 488320.,
      541280., 542880., 544480., 546080., 559240., 560880., 562520., 564160.,
      477155., 478590., 480025., 481460., 492870., 494340., 495810., 497280.,
      411860., 413120., 414380., 415640., 425330., 426620., 427910., 429200.,
      541416., 543072., 544728., 546384., 557580., 559272., 560964., 562656.,
      635446., 637420., 639394., 641368., 654304., 656320., 658336., 660352.,
      730304., 732608., 734912., 737216., 751856., 754208., 756560., 758912.,
      640570., 642628., 644686., 646744., 659428., 661528., 663628., 665728.,
      550200., 552000., 553800., 555600., 566364., 568200., 570036., 571872.,
      693364., 695632., 697900., 700168., 712222., 714532., 716842., 719152.,
      810215., 812910., 815605., 818300., 832216., 834960., 837704., 840448.,
      927136., 930272., 933408., 936544., 952280., 955472., 958664., 961856.,
      809921., 812714., 815507., 818300., 831922., 834764., 837606., 840448.,
      692860., 695296., 697732., 700168., 711718., 714196., 716674., 719152.,
      548904., 551136., 553368., 555600., 565068., 567336., 569604., 571872.,
      638806., 641452., 644098., 646744., 657664., 660352., 663040., 665728.,
      728000., 731072., 734144., 737216., 749552., 752672., 755792., 758912.,
      633178., 635908., 638638., 641368., 652036., 654808., 657580., 660352.,
      539256., 541632., 544008., 546384., 555420., 557832., 560244., 562656.,
      409340., 411440., 413540., 415640., 422810., 424940., 427070., 429200.,
      474005., 476490., 478975., 481460., 489720., 492240., 494760., 497280.,
      537440., 540320., 543200., 546080., 555400., 558320., 561240., 564160.,
      464835., 467390., 469945., 472500., 480550., 483140., 485730., 488320.,
      393620., 395840., 398060., 400280., 407090., 409340., 411590., 413840.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15136., 15376., 15616., 15856., 16684., 16936., 17188., 17440., 16216.,
      16480., 16744., 17008., 17860., 18136., 18412., 18688., 17296., 17584.,
      17872., 18160., 19036., 19336., 19636., 19936., 18376., 18688., 19000.,
      19312., 20212., 20536., 20860., 21184., 19456., 19792., 20128., 20464.,
      21388., 21736., 22084., 22432., 23776., 24208., 24640., 25072., 26092.,
      26536., 26980., 27424., 24856., 25312., 25768., 26224., 27268., 27736.,
      28204., 28672., 25936., 26416., 26896., 27376., 28444., 28936., 29428.,
      29920., 27016., 27520., 28024., 28528., 29620., 30136., 30652., 31168.,
      28096., 28624., 29152., 29680., 30796., 31336., 31876., 32416., 32416.,
      33040., 33664., 34288., 35500., 36136., 36772., 37408., 33496., 34144.,
      34792., 35440., 36676., 37336., 37996., 38656., 34576., 35248., 35920.,
      36592., 37852., 38536., 39220., 39904., 35656., 36352., 37048., 37744.,
      39028., 39736., 40444., 41152., 36736., 37456., 38176., 38896., 40204.,
      40936., 41668., 42400., 41056., 41872., 42688., 43504., 44908., 45736.,
      46564., 47392., 42136., 42976., 43816., 44656., 46084., 46936., 47788.,
      48640., 43216., 44080., 44944., 45808., 47260., 48136., 49012., 49888.,
      44296., 45184., 46072., 46960., 48436., 49336., 50236., 51136., 45376.,
      46288., 47200., 48112., 49612., 50536., 51460., 52384., 49696., 50704.,
      51712., 52720., 54316., 55336., 56356., 57376., 50776., 51808., 52840.,
      53872., 55492., 56536., 57580., 58624., 51856., 52912., 53968., 55024.,
      56668., 57736., 58804., 59872., 52936., 54016., 55096., 56176., 57844.,
      58936., 60028., 61120., 54016., 55120., 56224., 57328., 59020., 60136.,
      61252., 62368.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      393590., 400280., 407030., 413840., 464695., 472500., 480375., 488320.,
      537160., 546080., 555080., 564160., 473655., 481460., 489335., 497280.,
      408950., 415640., 422390., 429200., 538356., 546384., 554484., 562656.,
      632002., 641368., 650818., 660352., 726512., 737216., 748016., 758912.,
      637378., 646744., 656194., 665728., 547572., 555600., 563700., 571872.,
      690802., 700168., 709618., 719152., 807373., 818300., 829325., 840448.,
      924056., 936544., 949144., 961856., 807373., 818300., 829325., 840448.,
      690802., 700168., 709618., 719152., 547572., 555600., 563700., 571872.,
      637378., 646744., 656194., 665728., 726512., 737216., 748016., 758912.,
      632002., 641368., 650818., 660352., 538356., 546384., 554484., 562656.,
      408950., 415640., 422390., 429200., 473655., 481460., 489335., 497280.,
      537160., 546080., 555080., 564160., 464695., 472500., 480375., 488320.,
      393590., 400280., 407030., 413840.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15100., 15856., 16636., 17440., 16204., 17008., 17836., 18688., 17308.,
      18160., 19036., 19936., 18412., 19312., 20236., 21184., 19516., 20464.,
      21436., 22432., 23932., 25072., 26236., 27424., 25036., 26224., 27436.,
      28672., 26140., 27376., 28636., 29920., 27244., 28528., 29836., 31168.,
      28348., 29680., 31036., 32416., 32764., 34288., 35836., 37408., 33868.,
      35440., 37036., 38656., 34972., 36592., 38236., 39904., 36076., 37744.,
      39436., 41152., 37180., 38896., 40636., 42400., 41596., 43504., 45436.,
      47392., 42700., 44656., 46636., 48640., 43804., 45808., 47836., 49888.,
      44908., 46960., 49036., 51136., 46012., 48112., 50236., 52384., 50428.,
      52720., 55036., 57376., 51532., 53872., 56236., 58624., 52636., 55024.,
      57436., 59872., 53740., 56176., 58636., 61120., 54844., 57328., 59836.,
      62368.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      784930.,  787180.,  798280.,  800560.,  811750.,  814060.,  825340.,
      827680.,  926695.,  929390.,  942270.,  945000.,  957985.,  960750.,
      973840.,  976640.,  1071160., 1074320., 1088960., 1092160., 1106920.,
      1110160., 1125040., 1128320., 944475.,  947310.,  960050.,  962920.,
      975765.,  978670.,  991620.,  994560.,  815410.,  817900.,  828760.,
      831280.,  842230.,  844780.,  855820.,  858400.,  1073436., 1076712.,
      1089456., 1092768., 1105620., 1108968., 1121928., 1125312., 1260098.,
      1264004., 1278788., 1282736., 1297646., 1301636., 1316672., 1320704.,
      1448464., 1453024., 1469824., 1474432., 1491376., 1496032., 1513120.,
      1517824., 1270682., 1274756., 1289372., 1293488., 1308230., 1312388.,
      1327256., 1331456., 1091580., 1095144., 1107600., 1111200., 1123764.,
      1127400., 1140072., 1143744., 1377110., 1381604., 1395800., 1400336.,
      1414658., 1419236., 1433684., 1438304., 1609405., 1614746., 1631210.,
      1636600., 1653211., 1658650., 1675408., 1680896., 1841896., 1848112.,
      1866816., 1873088., 1891960., 1898288., 1917328., 1923712., 1609209.,
      1614746., 1631014., 1636600., 1653015., 1658650., 1675212., 1680896.,
      1376774., 1381604., 1395464., 1400336., 1414322., 1419236., 1433348.,
      1438304., 1090716., 1095144., 1106736., 1111200., 1122900., 1127400.,
      1139208., 1143744., 1269506., 1274756., 1288196., 1293488., 1307054.,
      1312388., 1326080., 1331456., 1446928., 1453024., 1468288., 1474432.,
      1489840., 1496032., 1511584., 1517824., 1258586., 1264004., 1277276.,
      1282736., 1296134., 1301636., 1315160., 1320704., 1071996., 1076712.,
      1088016., 1092768., 1104180., 1108968., 1120488., 1125312., 813730.,
      817900.,  827080.,  831280.,  840550.,  844780.,  854140.,  858400.,
      942375.,  947310.,  957950.,  962920.,  973665.,  978670.,  989520.,
      994560.,  1068600., 1074320., 1086400., 1092160., 1104360., 1110160.,
      1122480., 1128320., 924315.,  929390.,  939890.,  945000.,  955605.,
      960750.,  971460.,  976640.,  782770.,  787180.,  796120.,  800560.,
      809590.,  814060.,  823180.,  827680.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29732.,  30200.,  31232.,  31712.,  32780.,  33272.,  34376.,  34880.,
      31892.,  32408.,  33488.,  34016.,  35132.,  35672.,  36824.,  37376.,
      34052.,  34616.,  35744.,  36320.,  37484.,  38072.,  39272.,  39872.,
      36212.,  36824.,  38000.,  38624.,  39836.,  40472.,  41720.,  42368.,
      38372.,  39032.,  40256.,  40928.,  42188.,  42872.,  44168.,  44864.,
      47012.,  47864.,  49280.,  50144.,  51596.,  52472.,  53960.,  54848.,
      49172.,  50072.,  51536.,  52448.,  53948.,  54872.,  56408.,  57344.,
      51332.,  52280.,  53792.,  54752.,  56300.,  57272.,  58856.,  59840.,
      53492.,  54488.,  56048.,  57056.,  58652.,  59672.,  61304.,  62336.,
      55652.,  56696.,  58304.,  59360.,  61004.,  62072.,  63752.,  64832.,
      64292.,  65528.,  67328.,  68576.,  70412.,  71672.,  73544.,  74816.,
      66452.,  67736.,  69584.,  70880.,  72764.,  74072.,  75992.,  77312.,
      68612.,  69944.,  71840.,  73184.,  75116.,  76472.,  78440.,  79808.,
      70772.,  72152.,  74096.,  75488.,  77468.,  78872.,  80888.,  82304.,
      72932.,  74360.,  76352.,  77792.,  79820.,  81272.,  83336.,  84800.,
      81572.,  83192.,  85376.,  87008.,  89228.,  90872.,  93128.,  94784.,
      83732.,  85400.,  87632.,  89312.,  91580.,  93272.,  95576.,  97280.,
      85892.,  87608.,  89888.,  91616.,  93932.,  95672.,  98024.,  99776.,
      88052.,  89816.,  92144.,  93920.,  96284.,  98072.,  100472., 102272.,
      90212.,  92024.,  94400.,  96224.,  98636.,  100472., 102920., 104768.,
      98852.,  100856., 103424., 105440., 108044., 110072., 112712., 114752.,
      101012., 103064., 105680., 107744., 110396., 112472., 115160., 117248.,
      103172., 105272., 107936., 110048., 112748., 114872., 117608., 119744.,
      105332., 107480., 110192., 112352., 115100., 117272., 120056., 122240.,
      107492., 109688., 112448., 114656., 117452., 119672., 122504., 124736.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1567610., 1569860., 1572110., 1574360., 1594280., 1596560., 1598840.,
      1601120., 1621190., 1623500., 1625810., 1628120., 1648340., 1650680.,
      1653020., 1655360., 1850695., 1853390., 1856085., 1858780., 1881810.,
      1884540., 1887270., 1890000., 1913205., 1915970., 1918735., 1921500.,
      1944880., 1947680., 1950480., 1953280., 2139160., 2142320., 2145480.,
      2148640., 2174720., 2177920., 2181120., 2184320., 2210600., 2213840.,
      2217080., 2220320., 2246800., 2250080., 2253360., 2256640., 1886115.,
      1888950., 1891785., 1894620., 1917230., 1920100., 1922970., 1925840.,
      1948625., 1951530., 1954435., 1957340., 1980300., 1983240., 1986180.,
      1989120., 1628330., 1630820., 1633310., 1635800., 1655000., 1657520.,
      1660040., 1662560., 1681910., 1684460., 1687010., 1689560., 1709060.,
      1711640., 1714220., 1716800., 2143596., 2146872., 2150148., 2153424.,
      2175600., 2178912., 2182224., 2185536., 2207892., 2211240., 2214588.,
      2217936., 2240472., 2243856., 2247240., 2250624., 2516290., 2520196.,
      2524102., 2528008., 2553628., 2557576., 2561524., 2565472., 2591302.,
      2595292., 2599282., 2603272., 2629312., 2633344., 2637376., 2641408.,
      2892368., 2896928., 2901488., 2906048., 2935040., 2939648., 2944256.,
      2948864., 2978096., 2982752., 2987408., 2992064., 3021536., 3026240.,
      3030944., 3035648., 2537290., 2541364., 2545438., 2549512., 2574628.,
      2578744., 2582860., 2586976., 2612302., 2616460., 2620618., 2624776.,
      2650312., 2654512., 2658712., 2662912., 2179596., 2183160., 2186724.,
      2190288., 2211600., 2215200., 2218800., 2222400., 2243892., 2247528.,
      2251164., 2254800., 2276472., 2280144., 2283816., 2287488., 2749726.,
      2754220., 2758714., 2763208., 2787064., 2791600., 2796136., 2800672.,
      2824738., 2829316., 2833894., 2838472., 2862748., 2867368., 2871988.,
      2876608., 3213469., 3218810., 3224151., 3229492., 3257030., 3262420.,
      3267810., 3273200., 3300983., 3306422., 3311861., 3317300., 3345328.,
      3350816., 3356304., 3361792., 3677576., 3683792., 3690008., 3696224.,
      3727360., 3733632., 3739904., 3746176., 3777592., 3783920., 3790248.,
      3796576., 3828272., 3834656., 3841040., 3847424., 3212881., 3218418.,
      3223955., 3229492., 3256442., 3262028., 3267614., 3273200., 3300395.,
      3306030., 3311665., 3317300., 3344740., 3350424., 3356108., 3361792.,
      2748718., 2753548., 2758378., 2763208., 2786056., 2790928., 2795800.,
      2800672., 2823730., 2828644., 2833558., 2838472., 2861740., 2866696.,
      2871652., 2876608., 2177004., 2181432., 2185860., 2190288., 2209008.,
      2213472., 2217936., 2222400., 2241300., 2245800., 2250300., 2254800.,
      2273880., 2278416., 2282952., 2287488., 2533762., 2539012., 2544262.,
      2549512., 2571100., 2576392., 2581684., 2586976., 2608774., 2614108.,
      2619442., 2624776., 2646784., 2652160., 2657536., 2662912., 2887760.,
      2893856., 2899952., 2906048., 2930432., 2936576., 2942720., 2948864.,
      2973488., 2979680., 2985872., 2992064., 3016928., 3023168., 3029408.,
      3035648., 2511754., 2517172., 2522590., 2528008., 2549092., 2554552.,
      2560012., 2565472., 2586766., 2592268., 2597770., 2603272., 2624776.,
      2630320., 2635864., 2641408., 2139276., 2143992., 2148708., 2153424.,
      2171280., 2176032., 2180784., 2185536., 2203572., 2208360., 2213148.,
      2217936., 2236152., 2240976., 2245800., 2250624., 1623290., 1627460.,
      1631630., 1635800., 1649960., 1654160., 1658360., 1662560., 1676870.,
      1681100., 1685330., 1689560., 1704020., 1708280., 1712540., 1716800.,
      1879815., 1884750., 1889685., 1894620., 1910930., 1915900., 1920870.,
      1925840., 1942325., 1947330., 1952335., 1957340., 1974000., 1979040.,
      1984080., 1989120., 2131480., 2137200., 2142920., 2148640., 2167040.,
      2172800., 2178560., 2184320., 2202920., 2208720., 2214520., 2220320.,
      2239120., 2244960., 2250800., 2256640., 1843555., 1848630., 1853705.,
      1858780., 1874670., 1879780., 1884890., 1890000., 1906065., 1911210.,
      1916355., 1921500., 1937740., 1942920., 1948100., 1953280., 1561130.,
      1565540., 1569950., 1574360., 1587800., 1592240., 1596680., 1601120.,
      1614710., 1619180., 1623650., 1628120., 1641860., 1646360., 1650860.,
      1655360.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58996.,  59464.,  59932.,  60400.,  61984.,  62464.,  62944.,  63424.,
      65068.,  65560.,  66052.,  66544.,  68248.,  68752.,  69256.,  69760.,
      63268.,  63784.,  64300.,  64816.,  66448.,  66976.,  67504.,  68032.,
      69724.,  70264.,  70804.,  71344.,  73096.,  73648.,  74200.,  74752.,
      67540.,  68104.,  68668.,  69232.,  70912.,  71488.,  72064.,  72640.,
      74380.,  74968.,  75556.,  76144.,  77944.,  78544.,  79144.,  79744.,
      71812.,  72424.,  73036.,  73648.,  75376.,  76000.,  76624.,  77248.,
      79036.,  79672.,  80308.,  80944.,  82792.,  83440.,  84088.,  84736.,
      76084.,  76744.,  77404.,  78064.,  79840.,  80512.,  81184.,  81856.,
      83692.,  84376.,  85060.,  85744.,  87640.,  88336.,  89032.,  89728.,
      93172.,  94024.,  94876.,  95728.,  97696.,  98560.,  99424.,  100288.,
      102316., 103192., 104068., 104944., 107032., 107920., 108808., 109696.,
      97444.,  98344.,  99244.,  100144., 102160., 103072., 103984., 104896.,
      106972., 107896., 108820., 109744., 111880., 112816., 113752., 114688.,
      101716., 102664., 103612., 104560., 106624., 107584., 108544., 109504.,
      111628., 112600., 113572., 114544., 116728., 117712., 118696., 119680.,
      105988., 106984., 107980., 108976., 111088., 112096., 113104., 114112.,
      116284., 117304., 118324., 119344., 121576., 122608., 123640., 124672.,
      110260., 111304., 112348., 113392., 115552., 116608., 117664., 118720.,
      120940., 122008., 123076., 124144., 126424., 127504., 128584., 129664.,
      127348., 128584., 129820., 131056., 133408., 134656., 135904., 137152.,
      139564., 140824., 142084., 143344., 145816., 147088., 148360., 149632.,
      131620., 132904., 134188., 135472., 137872., 139168., 140464., 141760.,
      144220., 145528., 146836., 148144., 150664., 151984., 153304., 154624.,
      135892., 137224., 138556., 139888., 142336., 143680., 145024., 146368.,
      148876., 150232., 151588., 152944., 155512., 156880., 158248., 159616.,
      140164., 141544., 142924., 144304., 146800., 148192., 149584., 150976.,
      153532., 154936., 156340., 157744., 160360., 161776., 163192., 164608.,
      144436., 145864., 147292., 148720., 151264., 152704., 154144., 155584.,
      158188., 159640., 161092., 162544., 165208., 166672., 168136., 169600.,
      161524., 163144., 164764., 166384., 169120., 170752., 172384., 174016.,
      176812., 178456., 180100., 181744., 184600., 186256., 187912., 189568.,
      165796., 167464., 169132., 170800., 173584., 175264., 176944., 178624.,
      181468., 183160., 184852., 186544., 189448., 191152., 192856., 194560.,
      170068., 171784., 173500., 175216., 178048., 179776., 181504., 183232.,
      186124., 187864., 189604., 191344., 194296., 196048., 197800., 199552.,
      174340., 176104., 177868., 179632., 182512., 184288., 186064., 187840.,
      190780., 192568., 194356., 196144., 199144., 200944., 202744., 204544.,
      178612., 180424., 182236., 184048., 186976., 188800., 190624., 192448.,
      195436., 197272., 199108., 200944., 203992., 205840., 207688., 209536.,
      195700., 197704., 199708., 201712., 204832., 206848., 208864., 210880.,
      214060., 216088., 218116., 220144., 223384., 225424., 227464., 229504.,
      199972., 202024., 204076., 206128., 209296., 211360., 213424., 215488.,
      218716., 220792., 222868., 224944., 228232., 230320., 232408., 234496.,
      204244., 206344., 208444., 210544., 213760., 215872., 217984., 220096.,
      223372., 225496., 227620., 229744., 233080., 235216., 237352., 239488.,
      208516., 210664., 212812., 214960., 218224., 220384., 222544., 224704.,
      228028., 230200., 232372., 234544., 237928., 240112., 242296., 244480.,
      212788., 214984., 217180., 219376., 222688., 224896., 227104., 229312.,
      232684., 234904., 237124., 239344., 242776., 245008., 247240., 249472.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15780., 19950., 24198., 20310., 16356., 20426., 25690., 31003., 25900.,
      20762., 25264., 31640., 38024., 31640., 25264., 20762., 25900., 31003.,
      25690., 20426., 16356., 20310., 24198., 19950., 15780.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      500.,  536.,  572.,  608.,  644.,  716.,  752.,  788.,  824.,
      860.,  932.,  968.,  1004., 1040., 1076., 1148., 1184., 1220.,
      1256., 1292., 1364., 1400., 1436., 1472., 1508.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31140., 31560., 39360., 39900., 47730., 48396., 40050., 40620., 32244.,
      32712., 40278., 40852., 50645., 51380., 61103., 62006., 51030., 51800.,
      40894., 41524., 49776., 50528., 62320., 63280., 74872., 76048., 62280.,
      63280., 49712., 50528., 40782., 41524., 50855., 51800., 60851., 62006.,
      50400., 51380., 40054., 40852., 32004., 32712., 39720., 40620., 47298.,
      48396., 38970., 39900., 30804., 31560.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      916.,  1000., 980.,  1072., 1044., 1144., 1108., 1216., 1172., 1288.,
      1300., 1432., 1364., 1504., 1428., 1576., 1492., 1648., 1556., 1720.,
      1684., 1864., 1748., 1936., 1812., 2008., 1876., 2080., 1940., 2152.,
      2068., 2296., 2132., 2368., 2196., 2440., 2260., 2512., 2324., 2584.,
      2452., 2728., 2516., 2800., 2580., 2872., 2644., 2944., 2708., 3016.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61860.,  62280.,  62700.,  63120.,  78180.,  78720.,  79260.,  79800.,
      94794.,  95460.,  96126.,  96792.,  79530.,  80100.,  80670.,  81240.,
      64020.,  64488.,  64956.,  65424.,  79982.,  80556.,  81130.,  81704.,
      100555., 101290., 102025., 102760., 121303., 122206., 123109., 124012.,
      101290., 102060., 102830., 103600., 81158.,  81788.,  82418.,  83048.,
      98800.,  99552.,  100304., 101056., 123680., 124640., 125600., 126560.,
      148568., 149744., 150920., 152096., 123560., 124560., 125560., 126560.,
      98608.,  99424.,  100240., 101056., 80822.,  81564.,  82306.,  83048.,
      100765., 101710., 102655., 103600., 120547., 121702., 122857., 124012.,
      99820.,  100800., 101780., 102760., 79310.,  80108.,  80906.,  81704.,
      63300.,  64008.,  64716.,  65424.,  78540.,  79440.,  80340.,  81240.,
      93498.,  94596.,  95694.,  96792.,  77010.,  77940.,  78870.,  79800.,
      60852.,  61608.,  62364.,  63120.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1748., 1832., 1916., 2000., 1868., 1960., 2052., 2144., 1988., 2088.,
      2188., 2288., 2108., 2216., 2324., 2432., 2228., 2344., 2460., 2576.,
      2468., 2600., 2732., 2864., 2588., 2728., 2868., 3008., 2708., 2856.,
      3004., 3152., 2828., 2984., 3140., 3296., 2948., 3112., 3276., 3440.,
      3188., 3368., 3548., 3728., 3308., 3496., 3684., 3872., 3428., 3624.,
      3820., 4016., 3548., 3752., 3956., 4160., 3668., 3880., 4092., 4304.,
      3908., 4136., 4364., 4592., 4028., 4264., 4500., 4736., 4148., 4392.,
      4636., 4880., 4268., 4520., 4772., 5024., 4388., 4648., 4908., 5168.,
      4628., 4904., 5180., 5456., 4748., 5032., 5316., 5600., 4868., 5160.,
      5452., 5744., 4988., 5288., 5588., 5888., 5108., 5416., 5724., 6032.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60792.,  63120.,  76890.,  79800.,  93300., 96792.,  78330.,  81240.,
      63096.,  65424.,  78988.,  81704.,  99365., 102760., 119938., 124012.,
      100205., 103600., 80332.,  83048.,  97952., 101056., 122680., 126560.,
      147440., 152096., 122680., 126560., 97952., 101056., 80332.,  83048.,
      100205., 103600., 119938., 124012., 99365., 102760., 78988.,  81704.,
      63096.,  65424.,  78330.,  81240.,  93300., 96792.,  76890.,  79800.,
      60792.,  63120.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1768., 2000., 1896., 2144., 2024., 2288., 2152., 2432., 2280., 2576.,
      2536., 2864., 2664., 3008., 2792., 3152., 2920., 3296., 3048., 3440.,
      3304., 3728., 3432., 3872., 3560., 4016., 3688., 4160., 3816., 4304.,
      4072., 4592., 4200., 4736., 4328., 4880., 4456., 5024., 4584., 5168.,
      4840., 5456., 4968., 5600., 5096., 5744., 5224., 5888., 5352., 6032.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120768., 121584., 125400., 126240., 152730., 153780., 158520., 159600.,
      185304., 186600., 192252., 193584., 155550., 156660., 161340., 162480.,
      125280., 126192., 129912., 130848., 156856., 157976., 162260., 163408.,
      197295., 198730., 204050., 205520., 238112., 239876., 246218., 248024.,
      198905., 200410., 205660., 207200., 159432., 160664., 164836., 166096.,
      194432., 195904., 200608., 202112., 243480., 245360., 251200., 253120.,
      292576., 294880., 301840., 304192., 243400., 245360., 251120., 253120.,
      194304., 195904., 200480., 202112., 159208., 160664., 164612., 166096.,
      198555., 200410., 205310., 207200., 237608., 239876., 245714., 248024.,
      196805., 198730., 203560., 205520., 156408., 157976., 161812., 163408.,
      124800., 126192., 129432., 130848., 154890., 156660., 160680., 162480.,
      184440., 186600., 191388., 193584., 151950., 153780., 157740., 159600.,
      120096., 121584., 124728., 126240.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3376.,  3536.,  3832.,  4000.,  3616.,  3792.,  4104.,  4288.,  3856.,
      4048.,  4376.,  4576.,  4096.,  4304.,  4648.,  4864.,  4336.,  4560.,
      4920.,  5152.,  4816.,  5072.,  5464.,  5728.,  5056.,  5328.,  5736.,
      6016.,  5296.,  5584.,  6008.,  6304.,  5536.,  5840.,  6280.,  6592.,
      5776.,  6096.,  6552.,  6880.,  6256.,  6608.,  7096.,  7456.,  6496.,
      6864.,  7368.,  7744.,  6736.,  7120.,  7640.,  8032.,  6976.,  7376.,
      7912.,  8320.,  7216.,  7632.,  8184.,  8608.,  7696.,  8144.,  8728.,
      9184.,  7936.,  8400.,  9000.,  9472.,  8176.,  8656.,  9272.,  9760.,
      8416.,  8912.,  9544.,  10048., 8656.,  9168.,  9816.,  10336., 9136.,
      9680.,  10360., 10912., 9376.,  9936.,  10632., 11200., 9616.,  10192.,
      10904., 11488., 9856.,  10448., 11176., 11776., 10096., 10704., 11448.,
      12064.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240720., 241536., 242352., 243168., 249960., 250800., 251640., 252480.,
      304410., 305460., 306510., 307560., 315960., 317040., 318120., 319200.,
      369312., 370608., 371904., 373200., 383172., 384504., 385836., 387168.,
      309990., 311100., 312210., 313320., 321540., 322680., 323820., 324960.,
      249648., 250560., 251472., 252384., 258888., 259824., 260760., 261696.,
      312592., 313712., 314832., 315952., 323372., 324520., 325668., 326816.,
      393155., 394590., 396025., 397460., 406630., 408100., 409570., 411040.,
      474460., 476224., 477988., 479752., 490630., 492436., 494242., 496048.,
      396305., 397810., 399315., 400820., 409780., 411320., 412860., 414400.,
      317632., 318864., 320096., 321328., 328412., 329672., 330932., 332192.,
      387392., 388864., 390336., 391808., 399712., 401216., 402720., 404224.,
      485080., 486960., 488840., 490720., 500480., 502400., 504320., 506240.,
      582848., 585152., 587456., 589760., 601328., 603680., 606032., 608384.,
      484840., 486800., 488760., 490720., 500240., 502240., 504240., 506240.,
      387008., 388608., 390208., 391808., 399328., 400960., 402592., 404224.,
      316960., 318416., 319872., 321328., 327740., 329224., 330708., 332192.,
      395255., 397110., 398965., 400820., 408730., 410620., 412510., 414400.,
      472948., 475216., 477484., 479752., 489118., 491428., 493738., 496048.,
      391685., 393610., 395535., 397460., 405160., 407120., 409080., 411040.,
      311248., 312816., 314384., 315952., 322028., 323624., 325220., 326816.,
      248208., 249600., 250992., 252384., 257448., 258864., 260280., 261696.,
      308010., 309780., 311550., 313320., 319560., 321360., 323160., 324960.,
      366720., 368880., 371040., 373200., 380580., 382776., 384972., 387168.,
      302070., 303900., 305730., 307560., 313620., 315480., 317340., 319200.,
      238704., 240192., 241680., 243168., 247944., 249456., 250968., 252480.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6592.,  6752.,  6912.,  7072.,  7496.,  7664.,  7832.,  8000.,  7056.,
      7232.,  7408.,  7584.,  8024.,  8208.,  8392.,  8576.,  7520.,  7712.,
      7904.,  8096.,  8552.,  8752.,  8952.,  9152.,  7984.,  8192.,  8400.,
      8608.,  9080.,  9296.,  9512.,  9728.,  8448.,  8672.,  8896.,  9120.,
      9608.,  9840.,  10072., 10304., 9376.,  9632.,  9888.,  10144., 10664.,
      10928., 11192., 11456., 9840.,  10112., 10384., 10656., 11192., 11472.,
      11752., 12032., 10304., 10592., 10880., 11168., 11720., 12016., 12312.,
      12608., 10768., 11072., 11376., 11680., 12248., 12560., 12872., 13184.,
      11232., 11552., 11872., 12192., 12776., 13104., 13432., 13760., 12160.,
      12512., 12864., 13216., 13832., 14192., 14552., 14912., 12624., 12992.,
      13360., 13728., 14360., 14736., 15112., 15488., 13088., 13472., 13856.,
      14240., 14888., 15280., 15672., 16064., 13552., 13952., 14352., 14752.,
      15416., 15824., 16232., 16640., 14016., 14432., 14848., 15264., 15944.,
      16368., 16792., 17216., 14944., 15392., 15840., 16288., 17000., 17456.,
      17912., 18368., 15408., 15872., 16336., 16800., 17528., 18000., 18472.,
      18944., 15872., 16352., 16832., 17312., 18056., 18544., 19032., 19520.,
      16336., 16832., 17328., 17824., 18584., 19088., 19592., 20096., 16800.,
      17312., 17824., 18336., 19112., 19632., 20152., 20672., 17728., 18272.,
      18816., 19360., 20168., 20720., 21272., 21824., 18192., 18752., 19312.,
      19872., 20696., 21264., 21832., 22400., 18656., 19232., 19808., 20384.,
      21224., 21808., 22392., 22976., 19120., 19712., 20304., 20896., 21752.,
      22352., 22952., 23552., 19584., 20192., 20800., 21408., 22280., 22896.,
      23512., 24128.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      238584., 243168., 247800., 252480., 301830., 307560., 313350., 319200.,
      366324., 373200., 380148., 387168., 307590., 313320., 319110., 324960.,
      247800., 252384., 257016., 261696., 310604., 315952., 321356., 326816.,
      390775., 397460., 404215., 411040., 471730., 479752., 487858., 496048.,
      394135., 400820., 407575., 414400., 315980., 321328., 326732., 332192.,
      385696., 391808., 397984., 404224., 483080., 490720., 498440., 506240.,
      580592., 589760., 599024., 608384., 483080., 490720., 498440., 506240.,
      385696., 391808., 397984., 404224., 315980., 321328., 326732., 332192.,
      394135., 400820., 407575., 414400., 471730., 479752., 487858., 496048.,
      390775., 397460., 404215., 411040., 310604., 315952., 321356., 326816.,
      247800., 252384., 257016., 261696., 307590., 313320., 319110., 324960.,
      366324., 373200., 380148., 387168., 301830., 307560., 313350., 319200.,
      238584., 243168., 247800., 252480.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6632.,  7072.,  7528.,  8000.,  7112.,  7584.,  8072.,  8576.,  7592.,
      8096.,  8616.,  9152.,  8072.,  8608.,  9160.,  9728.,  8552.,  9120.,
      9704.,  10304., 9512.,  10144., 10792., 11456., 9992.,  10656., 11336.,
      12032., 10472., 11168., 11880., 12608., 10952., 11680., 12424., 13184.,
      11432., 12192., 12968., 13760., 12392., 13216., 14056., 14912., 12872.,
      13728., 14600., 15488., 13352., 14240., 15144., 16064., 13832., 14752.,
      15688., 16640., 14312., 15264., 16232., 17216., 15272., 16288., 17320.,
      18368., 15752., 16800., 17864., 18944., 16232., 17312., 18408., 19520.,
      16712., 17824., 18952., 20096., 17192., 18336., 19496., 20672., 18152.,
      19360., 20584., 21824., 18632., 19872., 21128., 22400., 19112., 20384.,
      21672., 22976., 19592., 20896., 22216., 23552., 20072., 21408., 22760.,
      24128.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      475560.,  477168.,  484704.,  486336.,  493944.,  495600.,  503280.,
      504960.,  601590.,  603660.,  613020.,  615120.,  624570.,  626700.,
      636240.,  638400.,  730092.,  732648.,  743808.,  746400.,  757668.,
      760296.,  771672.,  774336.,  612990.,  615180.,  624420.,  626640.,
      635970.,  638220.,  647640.,  649920.,  493800.,  495600.,  502944.,
      504768.,  512184.,  514032.,  521520.,  523392.,  618996.,  621208.,
      629664.,  631904.,  640444.,  642712.,  651336.,  653632.,  778715.,
      781550.,  792050.,  794920.,  805525.,  808430.,  819140.,  822080.,
      939974.,  943460.,  955976.,  959504.,  972146.,  975716.,  988484.,
      992096.,  785295.,  788270.,  798630.,  801640.,  812105.,  815150.,
      825720.,  828800.,  629524.,  631960.,  640192.,  642656.,  650972.,
      653464.,  661864.,  664384.,  768480.,  771392.,  780672.,  783616.,
      792992.,  795968.,  805440.,  808448.,  962440.,  966160.,  977680.,
      981440.,  993080.,  996880.,  1008640., 1012480., 1156624., 1161184.,
      1174912., 1179520., 1193392., 1198048., 1212064., 1216768., 962280.,
      966160.,  977520.,  981440.,  992920.,  996880.,  1008480., 1012480.,
      768224.,  771392.,  780416.,  783616.,  792736.,  795968.,  805184.,
      808448.,  629076.,  631960.,  639744.,  642656.,  650524.,  653464.,
      661416.,  664384.,  784595.,  788270.,  797930.,  801640.,  811405.,
      815150.,  825020.,  828800.,  938966.,  943460.,  954968.,  959504.,
      971138.,  975716.,  987476.,  992096.,  777735.,  781550.,  791070.,
      794920.,  804545.,  808430.,  818160.,  822080.,  618100.,  621208.,
      628768.,  631904.,  639548.,  642712.,  650440.,  653632.,  492840.,
      495600.,  501984.,  504768.,  511224.,  514032.,  520560.,  523392.,
      611670.,  615180.,  623100.,  626640.,  634650.,  638220.,  646320.,
      649920.,  728364.,  732648.,  742080.,  746400.,  755940.,  760296.,
      769944.,  774336.,  600030.,  603660.,  611460.,  615120.,  623010.,
      626700.,  634680.,  638400.,  474216.,  477168.,  483360.,  486336.,
      492600.,  495600.,  501936.,  504960.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12952., 13264., 13824., 14144., 14728., 15056., 15664., 16000., 13880.,
      14224., 14816., 15168., 15784., 16144., 16784., 17152., 14808., 15184.,
      15808., 16192., 16840., 17232., 17904., 18304., 15736., 16144., 16800.,
      17216., 17896., 18320., 19024., 19456., 16664., 17104., 17792., 18240.,
      18952., 19408., 20144., 20608., 18520., 19024., 19776., 20288., 21064.,
      21584., 22384., 22912., 19448., 19984., 20768., 21312., 22120., 22672.,
      23504., 24064., 20376., 20944., 21760., 22336., 23176., 23760., 24624.,
      25216., 21304., 21904., 22752., 23360., 24232., 24848., 25744., 26368.,
      22232., 22864., 23744., 24384., 25288., 25936., 26864., 27520., 24088.,
      24784., 25728., 26432., 27400., 28112., 29104., 29824., 25016., 25744.,
      26720., 27456., 28456., 29200., 30224., 30976., 25944., 26704., 27712.,
      28480., 29512., 30288., 31344., 32128., 26872., 27664., 28704., 29504.,
      30568., 31376., 32464., 33280., 27800., 28624., 29696., 30528., 31624.,
      32464., 33584., 34432., 29656., 30544., 31680., 32576., 33736., 34640.,
      35824., 36736., 30584., 31504., 32672., 33600., 34792., 35728., 36944.,
      37888., 31512., 32464., 33664., 34624., 35848., 36816., 38064., 39040.,
      32440., 33424., 34656., 35648., 36904., 37904., 39184., 40192., 33368.,
      34384., 35648., 36672., 37960., 38992., 40304., 41344., 35224., 36304.,
      37632., 38720., 40072., 41168., 42544., 43648., 36152., 37264., 38624.,
      39744., 41128., 42256., 43664., 44800., 37080., 38224., 39616., 40768.,
      42184., 43344., 44784., 45952., 38008., 39184., 40608., 41792., 43240.,
      44432., 45904., 47104., 38936., 40144., 41600., 42816., 44296., 45520.,
      47024., 48256.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      949512.,  951120.,  952728.,  954336.,  967776.,  969408.,  971040.,
      972672.,  986232.,  987888.,  989544.,  991200.,  1004880., 1006560.,
      1008240., 1009920., 1201110., 1203180., 1205250., 1207320., 1223940.,
      1226040., 1228140., 1230240., 1247010., 1249140., 1251270., 1253400.,
      1270320., 1272480., 1274640., 1276800., 1457628., 1460184., 1462740.,
      1465296., 1485024., 1487616., 1490208., 1492800., 1512708., 1515336.,
      1517964., 1520592., 1540680., 1543344., 1546008., 1548672., 1223790.,
      1225980., 1228170., 1230360., 1246620., 1248840., 1251060., 1253280.,
      1269690., 1271940., 1274190., 1276440., 1293000., 1295280., 1297560.,
      1299840., 985800.,  987600.,  989400.,  991200.,  1004064., 1005888.,
      1007712., 1009536., 1022520., 1024368., 1026216., 1028064., 1041168.,
      1043040., 1044912., 1046784., 1235780., 1237992., 1240204., 1242416.,
      1257088., 1259328., 1261568., 1263808., 1278620., 1280888., 1283156.,
      1285424., 1300376., 1302672., 1304968., 1307264., 1554595., 1557430.,
      1560265., 1563100., 1581230., 1584100., 1586970., 1589840., 1608145.,
      1611050., 1613955., 1616860., 1635340., 1638280., 1641220., 1644160.,
      1876462., 1879948., 1883434., 1886920., 1908424., 1911952., 1915480.,
      1919008., 1940722., 1944292., 1947862., 1951432., 1973356., 1976968.,
      1980580., 1984192., 1567615., 1570590., 1573565., 1576540., 1594250.,
      1597260., 1600270., 1603280., 1621165., 1624210., 1627255., 1630300.,
      1648360., 1651440., 1654520., 1657600., 1256612., 1259048., 1261484.,
      1263920., 1277920., 1280384., 1282848., 1285312., 1299452., 1301944.,
      1304436., 1306928., 1321208., 1323728., 1326248., 1328768., 1534048.,
      1536960., 1539872., 1542784., 1558400., 1561344., 1564288., 1567232.,
      1583008., 1585984., 1588960., 1591936., 1607872., 1610880., 1613888.,
      1616896., 1921160., 1924880., 1928600., 1932320., 1951600., 1955360.,
      1959120., 1962880., 1982360., 1986160., 1989960., 1993760., 2013440.,
      2017280., 2021120., 2024960., 2308688., 2313248., 2317808., 2322368.,
      2345216., 2349824., 2354432., 2359040., 2382128., 2386784., 2391440.,
      2396096., 2419424., 2424128., 2428832., 2433536., 1920680., 1924560.,
      1928440., 1932320., 1951120., 1955040., 1958960., 1962880., 1981880.,
      1985840., 1989800., 1993760., 2012960., 2016960., 2020960., 2024960.,
      1533280., 1536448., 1539616., 1542784., 1557632., 1560832., 1564032.,
      1567232., 1582240., 1585472., 1588704., 1591936., 1607104., 1610368.,
      1613632., 1616896., 1255268., 1258152., 1261036., 1263920., 1276576.,
      1279488., 1282400., 1285312., 1298108., 1301048., 1303988., 1306928.,
      1319864., 1322832., 1325800., 1328768., 1565515., 1569190., 1572865.,
      1576540., 1592150., 1595860., 1599570., 1603280., 1619065., 1622810.,
      1626555., 1630300., 1646260., 1650040., 1653820., 1657600., 1873438.,
      1877932., 1882426., 1886920., 1905400., 1909936., 1914472., 1919008.,
      1937698., 1942276., 1946854., 1951432., 1970332., 1974952., 1979572.,
      1984192., 1551655., 1555470., 1559285., 1563100., 1578290., 1582140.,
      1585990., 1589840., 1605205., 1609090., 1612975., 1616860., 1632400.,
      1636320., 1640240., 1644160., 1233092., 1236200., 1239308., 1242416.,
      1254400., 1257536., 1260672., 1263808., 1275932., 1279096., 1282260.,
      1285424., 1297688., 1300880., 1304072., 1307264., 982920.,  985680.,
      988440.,  991200.,  1001184., 1003968., 1006752., 1009536., 1019640.,
      1022448., 1025256., 1028064., 1038288., 1041120., 1043952., 1046784.,
      1219830., 1223340., 1226850., 1230360., 1242660., 1246200., 1249740.,
      1253280., 1265730., 1269300., 1272870., 1276440., 1289040., 1292640.,
      1296240., 1299840., 1452444., 1456728., 1461012., 1465296., 1479840.,
      1484160., 1488480., 1492800., 1507524., 1511880., 1516236., 1520592.,
      1535496., 1539888., 1544280., 1548672., 1196430., 1200060., 1203690.,
      1207320., 1219260., 1222920., 1226580., 1230240., 1242330., 1246020.,
      1249710., 1253400., 1265640., 1269360., 1273080., 1276800., 945480.,
      948432.,  951384.,  954336.,  963744.,  966720.,  969696.,  972672.,
      982200.,  985200.,  988200.,  991200.,  1000848., 1003872., 1006896.,
      1009920.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25592., 25904., 26216., 26528., 27328., 27648., 27968., 28288., 29128.,
      29456., 29784., 30112., 30992., 31328., 31664., 32000., 27416., 27760.,
      28104., 28448., 29280., 29632., 29984., 30336., 31208., 31568., 31928.,
      32288., 33200., 33568., 33936., 34304., 29240., 29616., 29992., 30368.,
      31232., 31616., 32000., 32384., 33288., 33680., 34072., 34464., 35408.,
      35808., 36208., 36608., 31064., 31472., 31880., 32288., 33184., 33600.,
      34016., 34432., 35368., 35792., 36216., 36640., 37616., 38048., 38480.,
      38912., 32888., 33328., 33768., 34208., 35136., 35584., 36032., 36480.,
      37448., 37904., 38360., 38816., 39824., 40288., 40752., 41216., 36536.,
      37040., 37544., 38048., 39040., 39552., 40064., 40576., 41608., 42128.,
      42648., 43168., 44240., 44768., 45296., 45824., 38360., 38896., 39432.,
      39968., 40992., 41536., 42080., 42624., 43688., 44240., 44792., 45344.,
      46448., 47008., 47568., 48128., 40184., 40752., 41320., 41888., 42944.,
      43520., 44096., 44672., 45768., 46352., 46936., 47520., 48656., 49248.,
      49840., 50432., 42008., 42608., 43208., 43808., 44896., 45504., 46112.,
      46720., 47848., 48464., 49080., 49696., 50864., 51488., 52112., 52736.,
      43832., 44464., 45096., 45728., 46848., 47488., 48128., 48768., 49928.,
      50576., 51224., 51872., 53072., 53728., 54384., 55040., 47480., 48176.,
      48872., 49568., 50752., 51456., 52160., 52864., 54088., 54800., 55512.,
      56224., 57488., 58208., 58928., 59648., 49304., 50032., 50760., 51488.,
      52704., 53440., 54176., 54912., 56168., 56912., 57656., 58400., 59696.,
      60448., 61200., 61952., 51128., 51888., 52648., 53408., 54656., 55424.,
      56192., 56960., 58248., 59024., 59800., 60576., 61904., 62688., 63472.,
      64256., 52952., 53744., 54536., 55328., 56608., 57408., 58208., 59008.,
      60328., 61136., 61944., 62752., 64112., 64928., 65744., 66560., 54776.,
      55600., 56424., 57248., 58560., 59392., 60224., 61056., 62408., 63248.,
      64088., 64928., 66320., 67168., 68016., 68864., 58424., 59312., 60200.,
      61088., 62464., 63360., 64256., 65152., 66568., 67472., 68376., 69280.,
      70736., 71648., 72560., 73472., 60248., 61168., 62088., 63008., 64416.,
      65344., 66272., 67200., 68648., 69584., 70520., 71456., 72944., 73888.,
      74832., 75776., 62072., 63024., 63976., 64928., 66368., 67328., 68288.,
      69248., 70728., 71696., 72664., 73632., 75152., 76128., 77104., 78080.,
      63896., 64880., 65864., 66848., 68320., 69312., 70304., 71296., 72808.,
      73808., 74808., 75808., 77360., 78368., 79376., 80384., 65720., 66736.,
      67752., 68768., 70272., 71296., 72320., 73344., 74888., 75920., 76952.,
      77984., 79568., 80608., 81648., 82688., 69368., 70448., 71528., 72608.,
      74176., 75264., 76352., 77440., 79048., 80144., 81240., 82336., 83984.,
      85088., 86192., 87296., 71192., 72304., 73416., 74528., 76128., 77248.,
      78368., 79488., 81128., 82256., 83384., 84512., 86192., 87328., 88464.,
      89600., 73016., 74160., 75304., 76448., 78080., 79232., 80384., 81536.,
      83208., 84368., 85528., 86688., 88400., 89568., 90736., 91904., 74840.,
      76016., 77192., 78368., 80032., 81216., 82400., 83584., 85288., 86480.,
      87672., 88864., 90608., 91808., 93008., 94208., 76664., 77872., 79080.,
      80288., 81984., 83200., 84416., 85632., 87368., 88592., 89816., 91040.,
      92816., 94048., 95280., 96512.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26795., 32466., 38227., 32970., 27635., 34650., 41797., 49000., 42091.,
      35140., 42820., 51464., 60116., 51464., 42820., 35140., 42091., 49000.,
      41797., 34650., 27635., 32970., 38227., 32466., 26795.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1298., 1376., 1454., 1532., 1610., 1844., 1922., 2000., 2078.,
      2156., 2390., 2468., 2546., 2624., 2702., 2936., 3014., 3092.,
      3170., 3248., 3482., 3560., 3638., 3716., 3794.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52975.,  53590.,  64176.,  64932.,  75551., 76454., 65148.,  65940.,
      54595.,  55270.,  68460.,  69300.,  82565., 83594., 96775.,  98000.,
      83111.,  84182.,  69370.,  70280.,  84540., 85640., 101584., 102928.,
      118636., 120232., 101536., 102928., 84460., 85640., 69195.,  70280.,
      82859.,  84182.,  96432.,  98000.,  82229., 83594., 68145.,  69300.,
      54235.,  55270.,  64680.,  65940.,  74963., 76454., 63636.,  64932.,
      52495.,  53590.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2446., 2596., 2590., 2752., 2734., 2908., 2878., 3064., 3022., 3220.,
      3454., 3688., 3598., 3844., 3742., 4000., 3886., 4156., 4030., 4312.,
      4462., 4780., 4606., 4936., 4750., 5092., 4894., 5248., 5038., 5404.,
      5470., 5872., 5614., 6028., 5758., 6184., 5902., 6340., 6046., 6496.,
      6478., 6964., 6622., 7120., 6766., 7276., 6910., 7432., 7054., 7588.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      105335., 105950., 106565., 107180., 127596., 128352., 129108., 129864.,
      150199., 151102., 152005., 152908., 129504., 130296., 131088., 131880.,
      108515., 109190., 109865., 110540., 136080., 136920., 137760., 138600.,
      164101., 165130., 166159., 167188., 192325., 193550., 194775., 196000.,
      165151., 166222., 167293., 168364., 137830., 138740., 139650., 140560.,
      167980., 169080., 170180., 171280., 201824., 203168., 204512., 205856.,
      235676., 237272., 238868., 240464., 201680., 203072., 204464., 205856.,
      167740., 168920., 170100., 171280., 137305., 138390., 139475., 140560.,
      164395., 165718., 167041., 168364., 191296., 192864., 194432., 196000.,
      163093., 164458., 165823., 167188., 135135., 136290., 137445., 138600.,
      107435., 108470., 109505., 110540., 128100., 129360., 130620., 131880.,
      148435., 149926., 151417., 152908., 125976., 127272., 128568., 129864.,
      103895., 104990., 106085., 107180.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4742.,  4892.,  5042.,  5192.,  5018.,  5180.,  5342.,  5504.,  5294.,
      5468.,  5642.,  5816.,  5570.,  5756.,  5942.,  6128.,  5846.,  6044.,
      6242.,  6440.,  6674.,  6908.,  7142.,  7376.,  6950.,  7196.,  7442.,
      7688.,  7226.,  7484.,  7742.,  8000.,  7502.,  7772.,  8042.,  8312.,
      7778.,  8060.,  8342.,  8624.,  8606.,  8924.,  9242.,  9560.,  8882.,
      9212.,  9542.,  9872.,  9158.,  9500.,  9842.,  10184., 9434.,  9788.,
      10142., 10496., 9710.,  10076., 10442., 10808., 10538., 10940., 11342.,
      11744., 10814., 11228., 11642., 12056., 11090., 11516., 11942., 12368.,
      11366., 11804., 12242., 12680., 11642., 12092., 12542., 12992., 12470.,
      12956., 13442., 13928., 12746., 13244., 13742., 14240., 13022., 13532.,
      14042., 14552., 13298., 13820., 14342., 14864., 13574., 14108., 14642.,
      15176.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      103790., 107180., 125796., 129864., 148162., 152908., 127812., 131880.,
      107150., 110540., 134645., 138600., 162442., 167188., 190463., 196000.,
      163618., 168364., 136605., 140560., 166760., 171280., 200432., 205856.,
      234136., 240464., 200432., 205856., 166760., 171280., 136605., 140560.,
      163618., 168364., 190463., 196000., 162442., 167188., 134645., 138600.,
      107150., 110540., 127812., 131880., 148162., 152908., 125796., 129864.,
      103790., 107180.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4748.,  5192.,  5036.,  5504.,  5324.,  5816.,  5612.,  6128.,  5900.,
      6440.,  6764.,  7376.,  7052.,  7688.,  7340.,  8000.,  7628.,  8312.,
      7916.,  8624.,  8780.,  9560.,  9068.,  9872.,  9356.,  10184., 9644.,
      10496., 9932.,  10808., 10796., 11744., 11084., 12056., 11372., 12368.,
      11660., 12680., 11948., 12992., 12812., 13928., 13100., 14240., 13388.,
      14552., 13676., 14864., 13964., 15176.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      206380., 207580., 213130., 214360., 250116., 251592., 258216., 259728.,
      294560., 296324., 304010., 305816., 254076., 255624., 262176., 263760.,
      212980., 214300., 219730., 221080., 267645., 269290., 275520., 277200.,
      322868., 324884., 332318., 334376., 378525., 380926., 389550., 392000.,
      325136., 327236., 334586., 336728., 271425., 273210., 279300., 281120.,
      331360., 333520., 340360., 342560., 398224., 400864., 409024., 411712.,
      465136., 468272., 477736., 480928., 398128., 400864., 408928., 411712.,
      331200., 333520., 340200., 342560., 271075., 273210., 278950., 281120.,
      324632., 327236., 334082., 336728., 377839., 380926., 388864., 392000.,
      322196., 324884., 331646., 334376., 267015., 269290., 274890., 277200.,
      212260., 214300., 219010., 221080., 253140., 255624., 261240., 263760.,
      293384., 296324., 302834., 305816., 249036., 251592., 257136., 259728.,
      205420., 207580., 212170., 214360.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9208.,  9496.,  10084., 10384., 9760.,  10072., 10684., 11008., 10312.,
      10648., 11284., 11632., 10864., 11224., 11884., 12256., 11416., 11800.,
      12484., 12880., 13072., 13528., 14284., 14752., 13624., 14104., 14884.,
      15376., 14176., 14680., 15484., 16000., 14728., 15256., 16084., 16624.,
      15280., 15832., 16684., 17248., 16936., 17560., 18484., 19120., 17488.,
      18136., 19084., 19744., 18040., 18712., 19684., 20368., 18592., 19288.,
      20284., 20992., 19144., 19864., 20884., 21616., 20800., 21592., 22684.,
      23488., 21352., 22168., 23284., 24112., 21904., 22744., 23884., 24736.,
      22456., 23320., 24484., 25360., 23008., 23896., 25084., 25984., 24664.,
      25624., 26884., 27856., 25216., 26200., 27484., 28480., 25768., 26776.,
      28084., 29104., 26320., 27352., 28684., 29728., 26872., 27928., 29284.,
      30352.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      411560., 412760., 413960., 415160., 425030., 426260., 427490., 428720.,
      498756., 500232., 501708., 503184., 514920., 516432., 517944., 519456.,
      587356., 589120., 590884., 592648., 606214., 608020., 609826., 611632.,
      506604., 508152., 509700., 511248., 522768., 524352., 525936., 527520.,
      424640., 425960., 427280., 428600., 438110., 439460., 440810., 442160.,
      533645., 535290., 536935., 538580., 549360., 551040., 552720., 554400.,
      643720., 645736., 647752., 649768., 662578., 664636., 666694., 668752.,
      754649., 757050., 759451., 761852., 776650., 779100., 781550., 784000.,
      648172., 650272., 652372., 654472., 667030., 669172., 671314., 673456.,
      541065., 542850., 544635., 546420., 556780., 558600., 560420., 562240.,
      660560., 662720., 664880., 667040., 678520., 680720., 682920., 685120.,
      793808., 796448., 799088., 801728., 815360., 818048., 820736., 823424.,
      927136., 930272., 933408., 936544., 952280., 955472., 958664., 961856.,
      793520., 796256., 798992., 801728., 815072., 817856., 820640., 823424.,
      660080., 662400., 664720., 667040., 678040., 680400., 682760., 685120.,
      540015., 542150., 544285., 546420., 555730., 557900., 560070., 562240.,
      646660., 649264., 651868., 654472., 665518., 668164., 670810., 673456.,
      752591., 755678., 758765., 761852., 774592., 777728., 780864., 784000.,
      641704., 644392., 647080., 649768., 660562., 663292., 666022., 668752.,
      531755., 534030., 536305., 538580., 547470., 549780., 552090., 554400.,
      422480., 424520., 426560., 428600., 435950., 438020., 440090., 442160.,
      503796., 506280., 508764., 511248., 519960., 522480., 525000., 527520.,
      583828., 586768., 589708., 592648., 602686., 605668., 608650., 611632.,
      495516., 498072., 500628., 503184., 511680., 514272., 516864., 519456.,
      408680., 410840., 413000., 415160., 422150., 424340., 426530., 428720.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18128., 18416., 18704., 18992., 19868., 20168., 20468., 20768., 19208.,
      19520., 19832., 20144., 21044., 21368., 21692., 22016., 20288., 20624.,
      20960., 21296., 22220., 22568., 22916., 23264., 21368., 21728., 22088.,
      22448., 23396., 23768., 24140., 24512., 22448., 22832., 23216., 23600.,
      24572., 24968., 25364., 25760., 25688., 26144., 26600., 27056., 28100.,
      28568., 29036., 29504., 26768., 27248., 27728., 28208., 29276., 29768.,
      30260., 30752., 27848., 28352., 28856., 29360., 30452., 30968., 31484.,
      32000., 28928., 29456., 29984., 30512., 31628., 32168., 32708., 33248.,
      30008., 30560., 31112., 31664., 32804., 33368., 33932., 34496., 33248.,
      33872., 34496., 35120., 36332., 36968., 37604., 38240., 34328., 34976.,
      35624., 36272., 37508., 38168., 38828., 39488., 35408., 36080., 36752.,
      37424., 38684., 39368., 40052., 40736., 36488., 37184., 37880., 38576.,
      39860., 40568., 41276., 41984., 37568., 38288., 39008., 39728., 41036.,
      41768., 42500., 43232., 40808., 41600., 42392., 43184., 44564., 45368.,
      46172., 46976., 41888., 42704., 43520., 44336., 45740., 46568., 47396.,
      48224., 42968., 43808., 44648., 45488., 46916., 47768., 48620., 49472.,
      44048., 44912., 45776., 46640., 48092., 48968., 49844., 50720., 45128.,
      46016., 46904., 47792., 49268., 50168., 51068., 51968., 48368., 49328.,
      50288., 51248., 52796., 53768., 54740., 55712., 49448., 50432., 51416.,
      52400., 53972., 54968., 55964., 56960., 50528., 51536., 52544., 53552.,
      55148., 56168., 57188., 58208., 51608., 52640., 53672., 54704., 56324.,
      57368., 58412., 59456., 52688., 53744., 54800., 55856., 57500., 58568.,
      59636., 60704.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      408470., 415160., 421910., 428720., 495156., 503184., 511284., 519456.,
      583282., 592648., 602098., 611632., 503220., 511248., 519348., 527520.,
      421910., 428600., 435350., 442160., 530775., 538580., 546455., 554400.,
      640402., 649768., 659218., 668752., 750925., 761852., 772877., 784000.,
      645106., 654472., 663922., 673456., 538615., 546420., 554295., 562240.,
      658120., 667040., 676040., 685120., 791024., 801728., 812528., 823424.,
      924056., 936544., 949144., 961856., 791024., 801728., 812528., 823424.,
      658120., 667040., 676040., 685120., 538615., 546420., 554295., 562240.,
      645106., 654472., 663922., 673456., 750925., 761852., 772877., 784000.,
      640402., 649768., 659218., 668752., 530775., 538580., 546455., 554400.,
      421910., 428600., 435350., 442160., 503220., 511248., 519348., 527520.,
      583282., 592648., 602098., 611632., 495156., 503184., 511284., 519456.,
      408470., 415160., 421910., 428720.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18140., 18992., 19868., 20768., 19244., 20144., 21068., 22016., 20348.,
      21296., 22268., 23264., 21452., 22448., 23468., 24512., 22556., 23600.,
      24668., 25760., 25868., 27056., 28268., 29504., 26972., 28208., 29468.,
      30752., 28076., 29360., 30668., 32000., 29180., 30512., 31868., 33248.,
      30284., 31664., 33068., 34496., 33596., 35120., 36668., 38240., 34700.,
      36272., 37868., 39488., 35804., 37424., 39068., 40736., 36908., 38576.,
      40268., 41984., 38012., 39728., 41468., 43232., 41324., 43184., 45068.,
      46976., 42428., 44336., 46268., 48224., 43532., 45488., 47468., 49472.,
      44636., 46640., 48668., 50720., 45740., 47792., 49868., 51968., 49052.,
      51248., 53468., 55712., 50156., 52400., 54668., 56960., 51260., 53552.,
      55868., 58208., 52364., 54704., 57068., 59456., 53468., 55856., 58268.,
      60704.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      814570.,  816940.,  827920.,  830320.,  841390.,  843820.,  854980.,
      857440.,  987396.,  990312.,  1003416., 1006368., 1019580., 1022568.,
      1035888., 1038912., 1163078., 1166564., 1181768., 1185296., 1200626.,
      1204196., 1219652., 1223264., 1003380., 1006440., 1019400., 1022496.,
      1035564., 1038696., 1051872., 1055040., 841210.,  843820.,  854560.,
      857200.,  868030.,  870700.,  881620.,  884320.,  1058295., 1061550.,
      1073870., 1077160., 1089585., 1092910., 1105440., 1108800., 1276814.,
      1280804., 1295504., 1299536., 1314362., 1318436., 1333388., 1337504.,
      1497097., 1501850., 1518902., 1523704., 1540903., 1545754., 1563100.,
      1568000., 1286054., 1290212., 1304744., 1308944., 1323602., 1327844.,
      1342628., 1346912., 1073695., 1077230., 1089270., 1092840., 1104985.,
      1108590., 1120840., 1124480., 1311960., 1316240., 1329760., 1334080.,
      1347720., 1352080., 1365840., 1370240., 1576816., 1582048., 1598176.,
      1603456., 1619728., 1625056., 1641472., 1646848., 1841896., 1848112.,
      1866816., 1873088., 1891960., 1898288., 1917328., 1923712., 1576624.,
      1582048., 1597984., 1603456., 1619536., 1625056., 1641280., 1646848.,
      1311640., 1316240., 1329440., 1334080., 1347400., 1352080., 1365520.,
      1370240., 1072995., 1077230., 1088570., 1092840., 1104285., 1108590.,
      1120140., 1124480., 1285046., 1290212., 1303736., 1308944., 1322594.,
      1327844., 1341620., 1346912., 1495725., 1501850., 1517530., 1523704.,
      1539531., 1545754., 1561728., 1568000., 1275470., 1280804., 1294160.,
      1299536., 1313018., 1318436., 1332044., 1337504., 1057035., 1061550.,
      1072610., 1077160., 1088325., 1092910., 1104180., 1108800., 839770.,
      843820.,  853120.,  857200.,  866590.,  870700.,  880180.,  884320.,
      1001508., 1006440., 1017528., 1022496., 1033692., 1038696., 1050000.,
      1055040., 1160726., 1166564., 1179416., 1185296., 1198274., 1204196.,
      1217300., 1223264., 985236.,  990312.,  1001256., 1006368., 1017420.,
      1022568., 1033728., 1038912., 812650.,  816940.,  826000.,  830320.,
      839470.,  843820.,  853060.,  857440.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35716.,  36280.,  37408.,  37984.,  39148.,  39736.,  40936.,  41536.,
      37876.,  38488.,  39664.,  40288.,  41500.,  42136.,  43384.,  44032.,
      40036.,  40696.,  41920.,  42592.,  43852.,  44536.,  45832.,  46528.,
      42196.,  42904.,  44176.,  44896.,  46204.,  46936.,  48280.,  49024.,
      44356.,  45112.,  46432.,  47200.,  48556.,  49336.,  50728.,  51520.,
      50836.,  51736.,  53200.,  54112.,  55612.,  56536.,  58072.,  59008.,
      52996.,  53944.,  55456.,  56416.,  57964.,  58936.,  60520.,  61504.,
      55156.,  56152.,  57712.,  58720.,  60316.,  61336.,  62968.,  64000.,
      57316.,  58360.,  59968.,  61024.,  62668.,  63736.,  65416.,  66496.,
      59476.,  60568.,  62224.,  63328.,  65020.,  66136.,  67864.,  68992.,
      65956.,  67192.,  68992.,  70240.,  72076.,  73336.,  75208.,  76480.,
      68116.,  69400.,  71248.,  72544.,  74428.,  75736.,  77656.,  78976.,
      70276.,  71608.,  73504.,  74848.,  76780.,  78136.,  80104.,  81472.,
      72436.,  73816.,  75760.,  77152.,  79132.,  80536.,  82552.,  83968.,
      74596.,  76024.,  78016.,  79456.,  81484.,  82936.,  85000.,  86464.,
      81076.,  82648.,  84784.,  86368.,  88540.,  90136.,  92344.,  93952.,
      83236.,  84856.,  87040.,  88672.,  90892.,  92536.,  94792.,  96448.,
      85396.,  87064.,  89296.,  90976.,  93244.,  94936.,  97240.,  98944.,
      87556.,  89272.,  91552.,  93280.,  95596.,  97336.,  99688.,  101440.,
      89716.,  91480.,  93808.,  95584.,  97948.,  99736.,  102136., 103936.,
      96196.,  98104.,  100576., 102496., 105004., 106936., 109480., 111424.,
      98356.,  100312., 102832., 104800., 107356., 109336., 111928., 113920.,
      100516., 102520., 105088., 107104., 109708., 111736., 114376., 116416.,
      102676., 104728., 107344., 109408., 112060., 114136., 116824., 118912.,
      104836., 106936., 109600., 111712., 114412., 116536., 119272., 121408.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1626770., 1629140., 1631510., 1633880., 1653440., 1655840., 1658240.,
      1660640., 1680350., 1682780., 1685210., 1687640., 1707500., 1709960.,
      1712420., 1714880., 1971876., 1974792., 1977708., 1980624., 2003880.,
      2006832., 2009784., 2012736., 2036172., 2039160., 2042148., 2045136.,
      2068752., 2071776., 2074800., 2077824., 2322670., 2326156., 2329642.,
      2333128., 2360008., 2363536., 2367064., 2370592., 2397682., 2401252.,
      2404822., 2408392., 2435692., 2439304., 2442916., 2446528., 2003700.,
      2006760., 2009820., 2012880., 2035704., 2038800., 2041896., 2044992.,
      2067996., 2071128., 2074260., 2077392., 2100576., 2103744., 2106912.,
      2110080., 1679810., 1682420., 1685030., 1687640., 1706480., 1709120.,
      1711760., 1714400., 1733390., 1736060., 1738730., 1741400., 1760540.,
      1763240., 1765940., 1768640., 2113335., 2116590., 2119845., 2123100.,
      2144450., 2147740., 2151030., 2154320., 2175845., 2179170., 2182495.,
      2185820., 2207520., 2210880., 2214240., 2217600., 2549638., 2553628.,
      2557618., 2561608., 2586976., 2591008., 2595040., 2599072., 2624650.,
      2628724., 2632798., 2636872., 2662660., 2666776., 2670892., 2675008.,
      2989441., 2994194., 2998947., 3003700., 3033002., 3037804., 3042606.,
      3047408., 3076955., 3081806., 3086657., 3091508., 3121300., 3126200.,
      3131100., 3136000., 2567950., 2572108., 2576266., 2580424., 2605288.,
      2609488., 2613688., 2617888., 2642962., 2647204., 2651446., 2655688.,
      2680972., 2685256., 2689540., 2693824., 2143855., 2147390., 2150925.,
      2154460., 2174970., 2178540., 2182110., 2185680., 2206365., 2209970.,
      2213575., 2217180., 2238040., 2241680., 2245320., 2248960., 2619640.,
      2623920., 2628200., 2632480., 2655200., 2659520., 2663840., 2668160.,
      2691080., 2695440., 2699800., 2704160., 2727280., 2731680., 2736080.,
      2740480., 3148400., 3153632., 3158864., 3164096., 3191072., 3196352.,
      3201632., 3206912., 3234128., 3239456., 3244784., 3250112., 3277568.,
      3282944., 3288320., 3293696., 3677576., 3683792., 3690008., 3696224.,
      3727360., 3733632., 3739904., 3746176., 3777592., 3783920., 3790248.,
      3796576., 3828272., 3834656., 3841040., 3847424., 3147824., 3153248.,
      3158672., 3164096., 3190496., 3195968., 3201440., 3206912., 3233552.,
      3239072., 3244592., 3250112., 3276992., 3282560., 3288128., 3293696.,
      2618680., 2623280., 2627880., 2632480., 2654240., 2658880., 2663520.,
      2668160., 2690120., 2694800., 2699480., 2704160., 2726320., 2731040.,
      2735760., 2740480., 2141755., 2145990., 2150225., 2154460., 2172870.,
      2177140., 2181410., 2185680., 2204265., 2208570., 2212875., 2217180.,
      2235940., 2240280., 2244620., 2248960., 2564926., 2570092., 2575258.,
      2580424., 2602264., 2607472., 2612680., 2617888., 2639938., 2645188.,
      2650438., 2655688., 2677948., 2683240., 2688532., 2693824., 2985325.,
      2991450., 2997575., 3003700., 3028886., 3035060., 3041234., 3047408.,
      3072839., 3079062., 3085285., 3091508., 3117184., 3123456., 3129728.,
      3136000., 2545606., 2550940., 2556274., 2561608., 2582944., 2588320.,
      2593696., 2599072., 2620618., 2626036., 2631454., 2636872., 2658628.,
      2664088., 2669548., 2675008., 2109555., 2114070., 2118585., 2123100.,
      2140670., 2145220., 2149770., 2154320., 2172065., 2176650., 2181235.,
      2185820., 2203740., 2208360., 2212980., 2217600., 1675490., 1679540.,
      1683590., 1687640., 1702160., 1706240., 1710320., 1714400., 1729070.,
      1733180., 1737290., 1741400., 1756220., 1760360., 1764500., 1768640.,
      1998084., 2003016., 2007948., 2012880., 2030088., 2035056., 2040024.,
      2044992., 2062380., 2067384., 2072388., 2077392., 2094960., 2100000.,
      2105040., 2110080., 2315614., 2321452., 2327290., 2333128., 2352952.,
      2358832., 2364712., 2370592., 2390626., 2396548., 2402470., 2408392.,
      2428636., 2434600., 2440564., 2446528., 1965396., 1970472., 1975548.,
      1980624., 1997400., 2002512., 2007624., 2012736., 2029692., 2034840.,
      2039988., 2045136., 2062272., 2067456., 2072640., 2077824., 1621010.,
      1625300., 1629590., 1633880., 1647680., 1652000., 1656320., 1660640.,
      1674590., 1678940., 1683290., 1687640., 1701740., 1706120., 1710500.,
      1714880.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      70868.,  71432.,  71996.,  72560.,  74240.,  74816.,  75392.,  75968.,
      77708.,  78296.,  78884.,  79472.,  81272.,  81872.,  82472.,  83072.,
      75140.,  75752.,  76364.,  76976.,  78704.,  79328.,  79952.,  80576.,
      82364.,  83000.,  83636.,  84272.,  86120.,  86768.,  87416.,  88064.,
      79412.,  80072.,  80732.,  81392.,  83168.,  83840.,  84512.,  85184.,
      87020.,  87704.,  88388.,  89072.,  90968.,  91664.,  92360.,  93056.,
      83684.,  84392.,  85100.,  85808.,  87632.,  88352.,  89072.,  89792.,
      91676.,  92408.,  93140.,  93872.,  95816.,  96560.,  97304.,  98048.,
      87956.,  88712.,  89468.,  90224.,  92096.,  92864.,  93632.,  94400.,
      96332.,  97112.,  97892.,  98672.,  100664., 101456., 102248., 103040.,
      100772., 101672., 102572., 103472., 105488., 106400., 107312., 108224.,
      110300., 111224., 112148., 113072., 115208., 116144., 117080., 118016.,
      105044., 105992., 106940., 107888., 109952., 110912., 111872., 112832.,
      114956., 115928., 116900., 117872., 120056., 121040., 122024., 123008.,
      109316., 110312., 111308., 112304., 114416., 115424., 116432., 117440.,
      119612., 120632., 121652., 122672., 124904., 125936., 126968., 128000.,
      113588., 114632., 115676., 116720., 118880., 119936., 120992., 122048.,
      124268., 125336., 126404., 127472., 129752., 130832., 131912., 132992.,
      117860., 118952., 120044., 121136., 123344., 124448., 125552., 126656.,
      128924., 130040., 131156., 132272., 134600., 135728., 136856., 137984.,
      130676., 131912., 133148., 134384., 136736., 137984., 139232., 140480.,
      142892., 144152., 145412., 146672., 149144., 150416., 151688., 152960.,
      134948., 136232., 137516., 138800., 141200., 142496., 143792., 145088.,
      147548., 148856., 150164., 151472., 153992., 155312., 156632., 157952.,
      139220., 140552., 141884., 143216., 145664., 147008., 148352., 149696.,
      152204., 153560., 154916., 156272., 158840., 160208., 161576., 162944.,
      143492., 144872., 146252., 147632., 150128., 151520., 152912., 154304.,
      156860., 158264., 159668., 161072., 163688., 165104., 166520., 167936.,
      147764., 149192., 150620., 152048., 154592., 156032., 157472., 158912.,
      161516., 162968., 164420., 165872., 168536., 170000., 171464., 172928.,
      160580., 162152., 163724., 165296., 167984., 169568., 171152., 172736.,
      175484., 177080., 178676., 180272., 183080., 184688., 186296., 187904.,
      164852., 166472., 168092., 169712., 172448., 174080., 175712., 177344.,
      180140., 181784., 183428., 185072., 187928., 189584., 191240., 192896.,
      169124., 170792., 172460., 174128., 176912., 178592., 180272., 181952.,
      184796., 186488., 188180., 189872., 192776., 194480., 196184., 197888.,
      173396., 175112., 176828., 178544., 181376., 183104., 184832., 186560.,
      189452., 191192., 192932., 194672., 197624., 199376., 201128., 202880.,
      177668., 179432., 181196., 182960., 185840., 187616., 189392., 191168.,
      194108., 195896., 197684., 199472., 202472., 204272., 206072., 207872.,
      190484., 192392., 194300., 196208., 199232., 201152., 203072., 204992.,
      208076., 210008., 211940., 213872., 217016., 218960., 220904., 222848.,
      194756., 196712., 198668., 200624., 203696., 205664., 207632., 209600.,
      212732., 214712., 216692., 218672., 221864., 223856., 225848., 227840.,
      199028., 201032., 203036., 205040., 208160., 210176., 212192., 214208.,
      217388., 219416., 221444., 223472., 226712., 228752., 230792., 232832.,
      203300., 205352., 207404., 209456., 212624., 214688., 216752., 218816.,
      222044., 224120., 226196., 228272., 231560., 233648., 235736., 237824.,
      207572., 209672., 211772., 213872., 217088., 219200., 221312., 223424.,
      226700., 228824., 230948., 233072., 236408., 238544., 240680., 242816.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41934., 49336., 56840., 50008., 43086., 54187., 63504., 72884., 63896.,
      54859., 66920., 78176., 89440., 78176., 66920., 54859., 63896., 72884.,
      63504., 54187., 43086., 50008., 56840., 49336., 41934.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2632., 2768., 2904., 3040., 3176., 3720., 3856., 3992., 4128.,
      4264., 4808., 4944., 5080., 5216., 5352., 5896., 6032., 6168.,
      6304., 6440., 6984., 7120., 7256., 7392., 7528.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83022.,  83868.,  97664.,  98672.,  112504., 113680., 98966.,  100016.,
      85254.,  86172.,  107219., 108374., 125636., 127008., 144172., 145768.,
      126371., 127792., 108479., 109718., 132328., 133840., 154560., 156352.,
      176800., 178880., 154504., 156352., 132232., 133840., 108227., 109718.,
      126028., 127792., 143724., 145768., 125195., 127008., 106799., 108374.,
      84750.,  86172.,  98336.,  100016., 111736., 113680., 96950.,  98672.,
      82374.,  83868.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5032.,  5264.,  5288.,  5536.,  5544.,  5808.,  5800.,  6080.,  6056.,
      6352.,  7080.,  7440.,  7336.,  7712.,  7592.,  7984.,  7848.,  8256.,
      8104.,  8528.,  9128.,  9616.,  9384.,  9888.,  9640.,  10160., 9896.,
      10432., 10152., 10704., 11176., 11792., 11432., 12064., 11688., 12336.,
      11944., 12608., 12200., 12880., 13224., 13968., 13480., 14240., 13736.,
      14512., 13992., 14784., 14248., 15056.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      165198., 166044., 166890., 167736., 194320., 195328., 196336., 197344.,
      223832., 225008., 226184., 227360., 196882., 197932., 198982., 200032.,
      169590., 170508., 171426., 172344., 213283., 214438., 215593., 216748.,
      249900., 251272., 252644., 254016., 286748., 288344., 289940., 291536.,
      251321., 252742., 254163., 255584., 215719., 216958., 218197., 219436.,
      263144., 264656., 266168., 267680., 307328., 309120., 310912., 312704.,
      351520., 353600., 355680., 357760., 307160., 309008., 310856., 312704.,
      262856., 264464., 266072., 267680., 214963., 216454., 217945., 219436.,
      250292., 252056., 253820., 255584., 285404., 287448., 289492., 291536.,
      248577., 250390., 252203., 254016., 212023., 213598., 215173., 216748.,
      168078., 169500., 170922., 172344., 194992., 196672., 198352., 200032.,
      221528., 223472., 225416., 227360., 192178., 193900., 195622., 197344.,
      163254., 164748., 166242., 167736.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9832.,  10064., 10296., 10528., 10328., 10576., 10824., 11072., 10824.,
      11088., 11352., 11616., 11320., 11600., 11880., 12160., 11816., 12112.,
      12408., 12704., 13800., 14160., 14520., 14880., 14296., 14672., 15048.,
      15424., 14792., 15184., 15576., 15968., 15288., 15696., 16104., 16512.,
      15784., 16208., 16632., 17056., 17768., 18256., 18744., 19232., 18264.,
      18768., 19272., 19776., 18760., 19280., 19800., 20320., 19256., 19792.,
      20328., 20864., 19752., 20304., 20856., 21408., 21736., 22352., 22968.,
      23584., 22232., 22864., 23496., 24128., 22728., 23376., 24024., 24672.,
      23224., 23888., 24552., 25216., 23720., 24400., 25080., 25760., 25704.,
      26448., 27192., 27936., 26200., 26960., 27720., 28480., 26696., 27472.,
      28248., 29024., 27192., 27984., 28776., 29568., 27688., 28496., 29304.,
      30112.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      163092., 167736., 191926., 197344., 221168., 227360., 194614., 200032.,
      167700., 172344., 211330., 216748., 247695., 254016., 284312., 291536.,
      249263., 255584., 214018., 219436., 261488., 267680., 305480., 312704.,
      349504., 357760., 305480., 312704., 261488., 267680., 214018., 219436.,
      249263., 255584., 284312., 291536., 247695., 254016., 211330., 216748.,
      167700., 172344., 194614., 200032., 221168., 227360., 191926., 197344.,
      163092., 167736.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9808.,  10528., 10320., 11072., 10832., 11616., 11344., 12160., 11856.,
      12704., 13904., 14880., 14416., 15424., 14928., 15968., 15440., 16512.,
      15952., 17056., 18000., 19232., 18512., 19776., 19024., 20320., 19536.,
      20864., 20048., 21408., 22096., 23584., 22608., 24128., 23120., 24672.,
      23632., 25216., 24144., 25760., 26192., 27936., 26704., 28480., 27216.,
      29024., 27728., 29568., 28240., 30112.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      324528., 326184., 333780., 335472., 381878., 383852., 392672., 394688.,
      440032., 442336., 452368., 454720., 387170., 389228., 397964., 400064.,
      333600., 335400., 342852., 344688., 420392., 422660., 431186., 433496.,
      492695., 495390., 505288., 508032., 565488., 568624., 579880., 583072.,
      495733., 498526., 508326., 511168., 425600., 428036., 436394., 438872.,
      520000., 522976., 532336., 535360., 607432., 610960., 621824., 625408.,
      694912., 699008., 711360., 715520., 607320., 610960., 621712., 625408.,
      519808., 522976., 532144., 535360., 425096., 428036., 435890., 438872.,
      495047., 498526., 507640., 511168., 564592., 568624., 578984., 583072.,
      491813., 495390., 504406., 508032., 419552., 422660., 430346., 433496.,
      332592., 335400., 341844., 344688., 385910., 389228., 396704., 400064.,
      438496., 442336., 450832., 454720., 380450., 383852., 391244., 394688.,
      323232., 326184., 332484., 335472.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19168., 19616., 20592., 21056., 20160., 20640., 21648., 22144., 21152.,
      21664., 22704., 23232., 22144., 22688., 23760., 24320., 23136., 23712.,
      24816., 25408., 27104., 27808., 29040., 29760., 28096., 28832., 30096.,
      30848., 29088., 29856., 31152., 31936., 30080., 30880., 32208., 33024.,
      31072., 31904., 33264., 34112., 35040., 36000., 37488., 38464., 36032.,
      37024., 38544., 39552., 37024., 38048., 39600., 40640., 38016., 39072.,
      40656., 41728., 39008., 40096., 41712., 42816., 42976., 44192., 45936.,
      47168., 43968., 45216., 46992., 48256., 44960., 46240., 48048., 49344.,
      45952., 47264., 49104., 50432., 46944., 48288., 50160., 51520., 50912.,
      52384., 54384., 55872., 51904., 53408., 55440., 56960., 52896., 54432.,
      56496., 58048., 53888., 55456., 57552., 59136., 54880., 56480., 58608.,
      60224.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      647400.,  649056.,  650712.,  652368.,  665868.,  667560.,  669252.,
      670944.,  761782.,  763756.,  765730.,  767704.,  783328.,  785344.,
      787360.,  789376.,  877760.,  880064.,  882368.,  884672.,  902384.,
      904736.,  907088.,  909440.,  772282.,  774340.,  776398.,  778456.,
      793828.,  795928.,  798028.,  800128.,  665400.,  667200.,  669000.,
      670800.,  683868.,  685704.,  687540.,  689376.,  838516.,  840784.,
      843052.,  845320.,  860062.,  862372.,  864682.,  866992.,  982695.,
      985390.,  988085.,  990780.,  1007832., 1010576., 1013320., 1016064.,
      1127840., 1130976., 1134112., 1137248., 1156568., 1159760., 1162952.,
      1166144., 988673.,  991466.,  994259.,  997052.,  1013810., 1016652.,
      1019494., 1022336., 848764.,  851200.,  853636.,  856072.,  870310.,
      872788.,  875266.,  877744.,  1037024., 1040000., 1042976., 1045952.,
      1061648., 1064672., 1067696., 1070720., 1211336., 1214864., 1218392.,
      1221920., 1240064., 1243648., 1247232., 1250816., 1385728., 1389824.,
      1393920., 1398016., 1418560., 1422720., 1426880., 1431040., 1211000.,
      1214640., 1218280., 1221920., 1239728., 1243424., 1247120., 1250816.,
      1036448., 1039616., 1042784., 1045952., 1061072., 1064288., 1067504.,
      1070720., 847252.,  850192.,  853132.,  856072.,  868798.,  871780.,
      874762.,  877744.,  986615.,  990094.,  993573.,  997052.,  1011752.,
      1015280., 1018808., 1022336., 1125152., 1129184., 1133216., 1137248.,
      1153880., 1157968., 1162056., 1166144., 980049.,  983626.,  987203.,
      990780.,  1005186., 1008812., 1012438., 1016064., 835996.,  839104.,
      842212.,  845320.,  857542.,  860692.,  863842.,  866992.,  662376.,
      665184.,  667992.,  670800.,  680844.,  683688.,  686532.,  689376.,
      768502.,  771820.,  775138.,  778456.,  790048.,  793408.,  796768.,
      800128.,  873152.,  876992.,  880832.,  884672.,  897776.,  901664.,
      905552.,  909440.,  757498.,  760900.,  764302.,  767704.,  779044.,
      782488.,  785932.,  789376.,  643512.,  646464.,  649416.,  652368.,
      661980.,  664968.,  667956.,  670944.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37888.,  38336.,  38784.,  39232.,  40720.,  41184.,  41648.,  42112.,
      39840.,  40320.,  40800.,  41280.,  42800.,  43296.,  43792.,  44288.,
      41792.,  42304.,  42816.,  43328.,  44880.,  45408.,  45936.,  46464.,
      43744.,  44288.,  44832.,  45376.,  46960.,  47520.,  48080.,  48640.,
      45696.,  46272.,  46848.,  47424.,  49040.,  49632.,  50224.,  50816.,
      53504.,  54208.,  54912.,  55616.,  57360.,  58080.,  58800.,  59520.,
      55456.,  56192.,  56928.,  57664.,  59440.,  60192.,  60944.,  61696.,
      57408.,  58176.,  58944.,  59712.,  61520.,  62304.,  63088.,  63872.,
      59360.,  60160.,  60960.,  61760.,  63600.,  64416.,  65232.,  66048.,
      61312.,  62144.,  62976.,  63808.,  65680.,  66528.,  67376.,  68224.,
      69120.,  70080.,  71040.,  72000.,  74000.,  74976.,  75952.,  76928.,
      71072.,  72064.,  73056.,  74048.,  76080.,  77088.,  78096.,  79104.,
      73024.,  74048.,  75072.,  76096.,  78160.,  79200.,  80240.,  81280.,
      74976.,  76032.,  77088.,  78144.,  80240.,  81312.,  82384.,  83456.,
      76928.,  78016.,  79104.,  80192.,  82320.,  83424.,  84528.,  85632.,
      84736.,  85952.,  87168.,  88384.,  90640.,  91872.,  93104.,  94336.,
      86688.,  87936.,  89184.,  90432.,  92720.,  93984.,  95248.,  96512.,
      88640.,  89920.,  91200.,  92480.,  94800.,  96096.,  97392.,  98688.,
      90592.,  91904.,  93216.,  94528.,  96880.,  98208.,  99536.,  100864.,
      92544.,  93888.,  95232.,  96576.,  98960.,  100320., 101680., 103040.,
      100352., 101824., 103296., 104768., 107280., 108768., 110256., 111744.,
      102304., 103808., 105312., 106816., 109360., 110880., 112400., 113920.,
      104256., 105792., 107328., 108864., 111440., 112992., 114544., 116096.,
      106208., 107776., 109344., 110912., 113520., 115104., 116688., 118272.,
      108160., 109760., 111360., 112960., 115600., 117216., 118832., 120448.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      643188.,  652368.,  661620.,  670944.,  756994.,  767704.,  778498.,
      789376.,  872432.,  884672.,  897008.,  909440.,  767746.,  778456.,
      789250.,  800128.,  661620.,  670800.,  680052.,  689376.,  834610.,
      845320.,  856114.,  866992.,  978285.,  990780.,  1003373., 1016064.,
      1122968., 1137248., 1151640., 1166144., 984557.,  997052.,  1009645.,
      1022336., 845362.,  856072.,  866866.,  877744.,  1033712., 1045952.,
      1058288., 1070720., 1207640., 1221920., 1236312., 1250816., 1381696.,
      1398016., 1414464., 1431040., 1207640., 1221920., 1236312., 1250816.,
      1033712., 1045952., 1058288., 1070720., 845362.,  856072.,  866866.,
      877744.,  984557.,  997052.,  1009645., 1022336., 1122968., 1137248.,
      1151640., 1166144., 978285.,  990780.,  1003373., 1016064., 834610.,
      845320.,  856114.,  866992.,  661620.,  670800.,  680052.,  689376.,
      767746.,  778456.,  789250.,  800128.,  872432.,  884672.,  897008.,
      909440.,  756994.,  767704.,  778498.,  789376.,  643188.,  652368.,
      661620.,  670944.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37840.,  39232.,  40656.,  42112.,  39824.,  41280.,  42768.,  44288.,
      41808.,  43328.,  44880.,  46464.,  43792.,  45376.,  46992.,  48640.,
      45776.,  47424.,  49104.,  50816.,  53712.,  55616.,  57552.,  59520.,
      55696.,  57664.,  59664.,  61696.,  57680.,  59712.,  61776.,  63872.,
      59664.,  61760.,  63888.,  66048.,  61648.,  63808.,  66000.,  68224.,
      69584.,  72000.,  74448.,  76928.,  71568.,  74048.,  76560.,  79104.,
      73552.,  76096.,  78672.,  81280.,  75536.,  78144.,  80784.,  83456.,
      77520.,  80192.,  82896.,  85632.,  85456.,  88384.,  91344.,  94336.,
      87440.,  90432.,  93456.,  96512.,  89424.,  92480.,  95568.,  98688.,
      91408.,  94528.,  97680.,  100864., 93392.,  96576.,  99792.,  103040.,
      101328., 104768., 108240., 111744., 103312., 106816., 110352., 113920.,
      105296., 108864., 112464., 116096., 107280., 110912., 114576., 118272.,
      109264., 112960., 116688., 120448.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1283100., 1286376., 1301424., 1304736., 1319892., 1323240., 1338504.,
      1341888., 1510082., 1513988., 1531460., 1535408., 1553006., 1556996.,
      1574720., 1578752., 1740304., 1744864., 1764736., 1769344., 1789360.,
      1794016., 1814176., 1818880., 1531418., 1535492., 1552796., 1556912.,
      1574342., 1578500., 1596056., 1600256., 1319676., 1323240., 1338000.,
      1341600., 1356468., 1360104., 1375080., 1378752., 1664726., 1669220.,
      1686104., 1690640., 1707650., 1712228., 1729364., 1733984., 1951229.,
      1956570., 1976170., 1981560., 2001307., 2006746., 2026640., 2032128.,
      2239720., 2245936., 2268224., 2274496., 2296952., 2303280., 2325904.,
      2332288., 1963577., 1969114., 1988518., 1994104., 2013655., 2019290.,
      2038988., 2044672., 1685894., 1690724., 1707272., 1712144., 1728818.,
      1733732., 1750532., 1755488., 2061520., 2067424., 2085952., 2091904.,
      2110576., 2116576., 2135392., 2141440., 2408280., 2415280., 2436784.,
      2443840., 2465512., 2472624., 2494464., 2501632., 2755264., 2763392.,
      2787840., 2796032., 2820672., 2828928., 2853760., 2862080., 2408056.,
      2415280., 2436560., 2443840., 2465288., 2472624., 2494240., 2501632.,
      2061136., 2067424., 2085568., 2091904., 2110192., 2116576., 2135008.,
      2141440., 1684886., 1690724., 1706264., 1712144., 1727810., 1733732.,
      1749524., 1755488., 1962205., 1969114., 1987146., 1994104., 2012283.,
      2019290., 2037616., 2044672., 2237928., 2245936., 2266432., 2274496.,
      2295160., 2303280., 2324112., 2332288., 1949465., 1956570., 1974406.,
      1981560., 1999543., 2006746., 2024876., 2032128., 1663046., 1669220.,
      1684424., 1690640., 1705970., 1712228., 1727684., 1733984., 1317660.,
      1323240., 1335984., 1341600., 1354452., 1360104., 1373064., 1378752.,
      1528898., 1535492., 1550276., 1556912., 1571822., 1578500., 1593536.,
      1600256., 1737232., 1744864., 1761664., 1769344., 1786288., 1794016.,
      1811104., 1818880., 1507226., 1513988., 1528604., 1535408., 1550150.,
      1556996., 1571864., 1578752., 1280508., 1286376., 1298832., 1304736.,
      1317300., 1323240., 1335912., 1341888.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74800.,  75680.,  77568.,  78464.,  80400.,  81312.,  83296.,  84224.,
      78704.,  79648.,  81600.,  82560.,  84560.,  85536.,  87584.,  88576.,
      82608.,  83616.,  85632.,  86656.,  88720.,  89760.,  91872.,  92928.,
      86512.,  87584.,  89664.,  90752.,  92880.,  93984.,  96160.,  97280.,
      90416.,  91552.,  93696.,  94848.,  97040.,  98208.,  100448., 101632.,
      106032., 107424., 109824., 111232., 113680., 115104., 117600., 119040.,
      109936., 111392., 113856., 115328., 117840., 119328., 121888., 123392.,
      113840., 115360., 117888., 119424., 122000., 123552., 126176., 127744.,
      117744., 119328., 121920., 123520., 126160., 127776., 130464., 132096.,
      121648., 123296., 125952., 127616., 130320., 132000., 134752., 136448.,
      137264., 139168., 142080., 144000., 146960., 148896., 151904., 153856.,
      141168., 143136., 146112., 148096., 151120., 153120., 156192., 158208.,
      145072., 147104., 150144., 152192., 155280., 157344., 160480., 162560.,
      148976., 151072., 154176., 156288., 159440., 161568., 164768., 166912.,
      152880., 155040., 158208., 160384., 163600., 165792., 169056., 171264.,
      168496., 170912., 174336., 176768., 180240., 182688., 186208., 188672.,
      172400., 174880., 178368., 180864., 184400., 186912., 190496., 193024.,
      176304., 178848., 182400., 184960., 188560., 191136., 194784., 197376.,
      180208., 182816., 186432., 189056., 192720., 195360., 199072., 201728.,
      184112., 186784., 190464., 193152., 196880., 199584., 203360., 206080.,
      199728., 202656., 206592., 209536., 213520., 216480., 220512., 223488.,
      203632., 206624., 210624., 213632., 217680., 220704., 224800., 227840.,
      207536., 210592., 214656., 217728., 221840., 224928., 229088., 232192.,
      211440., 214560., 218688., 221824., 226000., 229152., 233376., 236544.,
      215344., 218528., 222720., 225920., 230160., 233376., 237664., 240896.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2562924., 2566200., 2569476., 2572752., 2599536., 2602848., 2606160.,
      2609472., 2636436., 2639784., 2643132., 2646480., 2673624., 2677008.,
      2680392., 2683776., 3016258., 3020164., 3024070., 3027976., 3058972.,
      3062920., 3066868., 3070816., 3102022., 3106012., 3110002., 3113992.,
      3145408., 3149440., 3153472., 3157504., 3476048., 3480608., 3485168.,
      3489728., 3524864., 3529472., 3534080., 3538688., 3574064., 3578720.,
      3583376., 3588032., 3623648., 3628352., 3633056., 3637760., 3058762.,
      3062836., 3066910., 3070984., 3101476., 3105592., 3109708., 3113824.,
      3144526., 3148684., 3152842., 3157000., 3187912., 3192112., 3196312.,
      3200512., 2635788., 2639352., 2642916., 2646480., 2672400., 2676000.,
      2679600., 2683200., 2709300., 2712936., 2716572., 2720208., 2746488.,
      2750160., 2753832., 2757504., 3324958., 3329452., 3333946., 3338440.,
      3367672., 3372208., 3376744., 3381280., 3410722., 3415300., 3419878.,
      3424456., 3454108., 3458728., 3463348., 3467968., 3897117., 3902458.,
      3907799., 3913140., 3946950., 3952340., 3957730., 3963120., 3997175.,
      4002614., 4008053., 4013492., 4047792., 4053280., 4058768., 4064256.,
      4473224., 4479440., 4485656., 4491872., 4530176., 4536448., 4542720.,
      4548992., 4587576., 4593904., 4600232., 4606560., 4645424., 4651808.,
      4658192., 4664576., 3921617., 3927154., 3932691., 3938228., 3971450.,
      3977036., 3982622., 3988208., 4021675., 4027310., 4032945., 4038580.,
      4072292., 4077976., 4083660., 4089344., 3366958., 3371788., 3376618.,
      3381448., 3409672., 3414544., 3419416., 3424288., 3452722., 3457636.,
      3462550., 3467464., 3496108., 3501064., 3506020., 3510976., 4117136.,
      4123040., 4128944., 4134848., 4165952., 4171904., 4177856., 4183808.,
      4215152., 4221152., 4227152., 4233152., 4264736., 4270784., 4276832.,
      4282880., 4809560., 4816560., 4823560., 4830560., 4866512., 4873568.,
      4880624., 4887680., 4923912., 4931024., 4938136., 4945248., 4981760.,
      4988928., 4996096., 5003264., 5502400., 5510528., 5518656., 5526784.,
      5567488., 5575680., 5583872., 5592064., 5633088., 5641344., 5649600.,
      5657856., 5699200., 5707520., 5715840., 5724160., 4808888., 4816112.,
      4823336., 4830560., 4865840., 4873120., 4880400., 4887680., 4923240.,
      4930576., 4937912., 4945248., 4981088., 4988480., 4995872., 5003264.,
      4115984., 4122272., 4128560., 4134848., 4164800., 4171136., 4177472.,
      4183808., 4214000., 4220384., 4226768., 4233152., 4263584., 4270016.,
      4276448., 4282880., 3363934., 3369772., 3375610., 3381448., 3406648.,
      3412528., 3418408., 3424288., 3449698., 3455620., 3461542., 3467464.,
      3493084., 3499048., 3505012., 3510976., 3917501., 3924410., 3931319.,
      3938228., 3967334., 3974292., 3981250., 3988208., 4017559., 4024566.,
      4031573., 4038580., 4068176., 4075232., 4082288., 4089344., 4467848.,
      4475856., 4483864., 4491872., 4524800., 4532864., 4540928., 4548992.,
      4582200., 4590320., 4598440., 4606560., 4640048., 4648224., 4656400.,
      4664576., 3891825., 3898930., 3906035., 3913140., 3941658., 3948812.,
      3955966., 3963120., 3991883., 3999086., 4006289., 4013492., 4042500.,
      4049752., 4057004., 4064256., 3319918., 3326092., 3332266., 3338440.,
      3362632., 3368848., 3375064., 3381280., 3405682., 3411940., 3418198.,
      3424456., 3449068., 3455368., 3461668., 3467968., 2629740., 2635320.,
      2640900., 2646480., 2666352., 2671968., 2677584., 2683200., 2703252.,
      2708904., 2714556., 2720208., 2740440., 2746128., 2751816., 2757504.,
      3051202., 3057796., 3064390., 3070984., 3093916., 3100552., 3107188.,
      3113824., 3136966., 3143644., 3150322., 3157000., 3180352., 3187072.,
      3193792., 3200512., 3466832., 3474464., 3482096., 3489728., 3515648.,
      3523328., 3531008., 3538688., 3564848., 3572576., 3580304., 3588032.,
      3614432., 3622208., 3629984., 3637760., 3007690., 3014452., 3021214.,
      3027976., 3050404., 3057208., 3064012., 3070816., 3093454., 3100300.,
      3107146., 3113992., 3136840., 3143728., 3150616., 3157504., 2555148.,
      2561016., 2566884., 2572752., 2591760., 2597664., 2603568., 2609472.,
      2628660., 2634600., 2640540., 2646480., 2665848., 2671824., 2677800.,
      2683776.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      148720., 149600., 150480., 151360., 154240., 155136., 156032., 156928.,
      159888., 160800., 161712., 162624., 165664., 166592., 167520., 168448.,
      156464., 157408., 158352., 159296., 162240., 163200., 164160., 165120.,
      168144., 169120., 170096., 171072., 174176., 175168., 176160., 177152.,
      164208., 165216., 166224., 167232., 170240., 171264., 172288., 173312.,
      176400., 177440., 178480., 179520., 182688., 183744., 184800., 185856.,
      171952., 173024., 174096., 175168., 178240., 179328., 180416., 181504.,
      184656., 185760., 186864., 187968., 191200., 192320., 193440., 194560.,
      179696., 180832., 181968., 183104., 186240., 187392., 188544., 189696.,
      192912., 194080., 195248., 196416., 199712., 200896., 202080., 203264.,
      210672., 212064., 213456., 214848., 218240., 219648., 221056., 222464.,
      225936., 227360., 228784., 230208., 233760., 235200., 236640., 238080.,
      218416., 219872., 221328., 222784., 226240., 227712., 229184., 230656.,
      234192., 235680., 237168., 238656., 242272., 243776., 245280., 246784.,
      226160., 227680., 229200., 230720., 234240., 235776., 237312., 238848.,
      242448., 244000., 245552., 247104., 250784., 252352., 253920., 255488.,
      233904., 235488., 237072., 238656., 242240., 243840., 245440., 247040.,
      250704., 252320., 253936., 255552., 259296., 260928., 262560., 264192.,
      241648., 243296., 244944., 246592., 250240., 251904., 253568., 255232.,
      258960., 260640., 262320., 264000., 267808., 269504., 271200., 272896.,
      272624., 274528., 276432., 278336., 282240., 284160., 286080., 288000.,
      291984., 293920., 295856., 297792., 301856., 303808., 305760., 307712.,
      280368., 282336., 284304., 286272., 290240., 292224., 294208., 296192.,
      300240., 302240., 304240., 306240., 310368., 312384., 314400., 316416.,
      288112., 290144., 292176., 294208., 298240., 300288., 302336., 304384.,
      308496., 310560., 312624., 314688., 318880., 320960., 323040., 325120.,
      295856., 297952., 300048., 302144., 306240., 308352., 310464., 312576.,
      316752., 318880., 321008., 323136., 327392., 329536., 331680., 333824.,
      303600., 305760., 307920., 310080., 314240., 316416., 318592., 320768.,
      325008., 327200., 329392., 331584., 335904., 338112., 340320., 342528.,
      334576., 336992., 339408., 341824., 346240., 348672., 351104., 353536.,
      358032., 360480., 362928., 365376., 369952., 372416., 374880., 377344.,
      342320., 344800., 347280., 349760., 354240., 356736., 359232., 361728.,
      366288., 368800., 371312., 373824., 378464., 380992., 383520., 386048.,
      350064., 352608., 355152., 357696., 362240., 364800., 367360., 369920.,
      374544., 377120., 379696., 382272., 386976., 389568., 392160., 394752.,
      357808., 360416., 363024., 365632., 370240., 372864., 375488., 378112.,
      382800., 385440., 388080., 390720., 395488., 398144., 400800., 403456.,
      365552., 368224., 370896., 373568., 378240., 380928., 383616., 386304.,
      391056., 393760., 396464., 399168., 404000., 406720., 409440., 412160.,
      396528., 399456., 402384., 405312., 410240., 413184., 416128., 419072.,
      424080., 427040., 430000., 432960., 438048., 441024., 444000., 446976.,
      404272., 407264., 410256., 413248., 418240., 421248., 424256., 427264.,
      432336., 435360., 438384., 441408., 446560., 449600., 452640., 455680.,
      412016., 415072., 418128., 421184., 426240., 429312., 432384., 435456.,
      440592., 443680., 446768., 449856., 455072., 458176., 461280., 464384.,
      419760., 422880., 426000., 429120., 434240., 437376., 440512., 443648.,
      448848., 452000., 455152., 458304., 463584., 466752., 469920., 473088.,
      427504., 430688., 433872., 437056., 442240., 445440., 448640., 451840.,
      457104., 460320., 463536., 466752., 472096., 475328., 478560., 481792.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      183912., 230340., 276924., 231060., 185064., 233490., 292200.,
      351015., 292650., 234210., 283644., 354690., 425754., 354690.,
      283644., 234210., 292650., 351015., 292200., 233490., 185064.,
      231060., 276924., 230340., 183912.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4350., 4428., 4506., 4584., 4662., 4818., 4896., 4974., 5052.,
      5130., 5286., 5364., 5442., 5520., 5598., 5754., 5832., 5910.,
      5988., 6066., 6222., 6300., 6378., 6456., 6534.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      365544., 367824., 457800., 460680., 550356., 553848., 459180., 462120.,
      367752., 370128., 463950., 466980., 580575., 584400., 697395., 702030.,
      581400., 585300., 465270., 468420., 563436., 567288., 704520., 709380.,
      845622., 851508., 704430., 709380., 563292., 567288., 465030., 468420.,
      581025., 585300., 696855., 702030., 580050., 584400., 463470., 466980.,
      367272., 370128., 458520., 462120., 549492., 553848., 457020., 460680.,
      364872., 367824.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8214.,  8700.,  8358.,  8856.,  8502.,  9012.,  8646.,  9168.,  8790.,
      9324.,  9078.,  9636.,  9222.,  9792.,  9366.,  9948.,  9510.,  10104.,
      9654.,  10260., 9942.,  10572., 10086., 10728., 10230., 10884., 10374.,
      11040., 10518., 11196., 10806., 11508., 10950., 11664., 11094., 11820.,
      11238., 11976., 11382., 12132., 11670., 12444., 11814., 12600., 11958.,
      12756., 12102., 12912., 12246., 13068.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      728808.,  731088.,  733368.,  735648.,  912720.,  915600.,  918480.,
      921360.,  1097220., 1100712., 1104204., 1107696., 915420.,  918360.,
      921300.,  924240.,  733128.,  735504.,  737880.,  740256.,  924870.,
      927900.,  930930.,  933960.,  1157325., 1161150., 1164975., 1168800.,
      1390155., 1394790., 1399425., 1404060., 1158900., 1162800., 1166700.,
      1170600., 927390.,  930540.,  933690.,  936840.,  1123020., 1126872.,
      1130724., 1134576., 1404180., 1409040., 1413900., 1418760., 1685358.,
      1691244., 1697130., 1703016., 1403910., 1408860., 1413810., 1418760.,
      1122588., 1126584., 1130580., 1134576., 926670.,  930060.,  933450.,
      936840.,  1157775., 1162050., 1166325., 1170600., 1388535., 1393710.,
      1398885., 1404060., 1155750., 1160100., 1164450., 1168800., 923430.,
      926940.,  930450.,  933960.,  731688.,  734544.,  737400.,  740256.,
      913440.,  917040.,  920640.,  924240.,  1094628., 1098984., 1103340.,
      1107696., 910380.,  914040.,  917700.,  921360.,  726792.,  729744.,
      732696.,  735648.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15942., 16428., 16914., 17400., 16218., 16716., 17214., 17712., 16494.,
      17004., 17514., 18024., 16770., 17292., 17814., 18336., 17046., 17580.,
      18114., 18648., 17598., 18156., 18714., 19272., 17874., 18444., 19014.,
      19584., 18150., 18732., 19314., 19896., 18426., 19020., 19614., 20208.,
      18702., 19308., 19914., 20520., 19254., 19884., 20514., 21144., 19530.,
      20172., 20814., 21456., 19806., 20460., 21114., 21768., 20082., 20748.,
      21414., 22080., 20358., 21036., 21714., 22392., 20910., 21612., 22314.,
      23016., 21186., 21900., 22614., 23328., 21462., 22188., 22914., 23640.,
      21738., 22476., 23214., 23952., 22014., 22764., 23514., 24264., 22566.,
      23340., 24114., 24888., 22842., 23628., 24414., 25200., 23118., 23916.,
      24714., 25512., 23394., 24204., 25014., 25824., 23670., 24492., 25314.,
      26136.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      725232.,  735648.,  908340.,  921360.,  1092072., 1107696., 911220.,
      924240.,  729840.,  740256.,  920940.,  933960.,  1152525., 1168800.,
      1384530., 1404060., 1154325., 1170600., 923820.,  936840.,  1118952.,
      1134576., 1399230., 1418760., 1679580., 1703016., 1399230., 1418760.,
      1118952., 1134576., 923820.,  936840.,  1154325., 1170600., 1384530.,
      1404060., 1152525., 1168800., 920940.,  933960.,  729840.,  740256.,
      911220.,  924240.,  1092072., 1107696., 908340.,  921360.,  725232.,
      735648.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16284., 17400., 16572., 17712., 16860., 18024., 17148., 18336., 17436.,
      18648., 18012., 19272., 18300., 19584., 18588., 19896., 18876., 20208.,
      19164., 20520., 19740., 21144., 20028., 21456., 20316., 21768., 20604.,
      22080., 20892., 22392., 21468., 23016., 21756., 23328., 22044., 23640.,
      22332., 23952., 22620., 24264., 23196., 24888., 23484., 25200., 23772.,
      25512., 24060., 25824., 24348., 26136.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1445952., 1450464., 1466736., 1471296., 1810980., 1816680., 1836960.,
      1842720., 2177232., 2184144., 2208408., 2215392., 1816620., 1822440.,
      1842600., 1848480., 1454976., 1459680., 1475760., 1480512., 1835880.,
      1841880., 1861860., 1867920., 2297475., 2305050., 2329950., 2337600.,
      2759880., 2769060., 2798850., 2808120., 2300925., 2308650., 2333400.,
      2341200., 1841400., 1847640., 1867380., 1873680., 2230272., 2237904.,
      2261448., 2269152., 2788830., 2798460., 2827800., 2837520., 3347496.,
      3359160., 3394260., 3406032., 2788650., 2798460., 2827620., 2837520.,
      2229984., 2237904., 2261160., 2269152., 1840920., 1847640., 1866900.,
      1873680., 2300175., 2308650., 2332650., 2341200., 2758800., 2769060.,
      2797770., 2808120., 2296425., 2305050., 2328900., 2337600., 1834920.,
      1841880., 1860900., 1867920., 1454016., 1459680., 1474800., 1480512.,
      1815300., 1822440., 1841280., 1848480., 2175504., 2184144., 2206680.,
      2215392., 1809420., 1816680., 1835400., 1842720., 1444608., 1450464.,
      1465392., 1471296.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31608., 32568., 33828., 34800., 32160., 33144., 34428., 35424., 32712.,
      33720., 35028., 36048., 33264., 34296., 35628., 36672., 33816., 34872.,
      36228., 37296., 34920., 36024., 37428., 38544., 35472., 36600., 38028.,
      39168., 36024., 37176., 38628., 39792., 36576., 37752., 39228., 40416.,
      37128., 38328., 39828., 41040., 38232., 39480., 41028., 42288., 38784.,
      40056., 41628., 42912., 39336., 40632., 42228., 43536., 39888., 41208.,
      42828., 44160., 40440., 41784., 43428., 44784., 41544., 42936., 44628.,
      46032., 42096., 43512., 45228., 46656., 42648., 44088., 45828., 47280.,
      43200., 44664., 46428., 47904., 43752., 45240., 47028., 48528., 44856.,
      46392., 48228., 49776., 45408., 46968., 48828., 50400., 45960., 47544.,
      49428., 51024., 46512., 48120., 50028., 51648., 47064., 48696., 50628.,
      52272.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2887392., 2891904., 2896416., 2900928., 2928912., 2933472., 2938032.,
      2942592., 3616260., 3621960., 3627660., 3633360., 3668160., 3673920.,
      3679680., 3685440., 4347552., 4354464., 4361376., 4368288., 4409832.,
      4416816., 4423800., 4430784., 3627420., 3633240., 3639060., 3644880.,
      3679320., 3685200., 3691080., 3696960., 2905248., 2909952., 2914656.,
      2919360., 2946768., 2951520., 2956272., 2961024., 3665760., 3671760.,
      3677760., 3683760., 3717660., 3723720., 3729780., 3735840., 4587375.,
      4594950., 4602525., 4610100., 4652250., 4659900., 4667550., 4675200.,
      5510580., 5519760., 5528940., 5538120., 5588430., 5597700., 5606970.,
      5616240., 4594125., 4601850., 4609575., 4617300., 4659000., 4666800.,
      4674600., 4682400., 3676560., 3682800., 3689040., 3695280., 3728460.,
      3734760., 3741060., 3747360., 4452912., 4460544., 4468176., 4475808.,
      4515192., 4522896., 4530600., 4538304., 5568030., 5577660., 5587290.,
      5596920., 5645880., 5655600., 5665320., 5675040., 6683328., 6694992.,
      6706656., 6718320., 6776748., 6788520., 6800292., 6812064., 5567490.,
      5577300., 5587110., 5596920., 5645340., 5655240., 5665140., 5675040.,
      4452048., 4459968., 4467888., 4475808., 4514328., 4522320., 4530312.,
      4538304., 3675120., 3681840., 3688560., 3695280., 3727020., 3733800.,
      3740580., 3747360., 4591875., 4600350., 4608825., 4617300., 4656750.,
      4665300., 4673850., 4682400., 5507340., 5517600., 5527860., 5538120.,
      5585190., 5595540., 5605890., 5616240., 4584225., 4592850., 4601475.,
      4610100., 4649100., 4657800., 4666500., 4675200., 3662880., 3669840.,
      3676800., 3683760., 3714780., 3721800., 3728820., 3735840., 2902368.,
      2908032., 2913696., 2919360., 2943888., 2949600., 2955312., 2961024.,
      3623460., 3630600., 3637740., 3644880., 3675360., 3682560., 3689760.,
      3696960., 4342368., 4351008., 4359648., 4368288., 4404648., 4413360.,
      4422072., 4430784., 3611580., 3618840., 3626100., 3633360., 3663480.,
      3670800., 3678120., 3685440., 2883360., 2889216., 2895072., 2900928.,
      2924880., 2930784., 2936688., 2942592.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      62256., 63216., 64176., 65136., 66684., 67656.,  68628.,  69600.,
      63336., 64320., 65304., 66288., 67860., 68856.,  69852.,  70848.,
      64416., 65424., 66432., 67440., 69036., 70056.,  71076.,  72096.,
      65496., 66528., 67560., 68592., 70212., 71256.,  72300.,  73344.,
      66576., 67632., 68688., 69744., 71388., 72456.,  73524.,  74592.,
      68736., 69840., 70944., 72048., 73740., 74856.,  75972.,  77088.,
      69816., 70944., 72072., 73200., 74916., 76056.,  77196.,  78336.,
      70896., 72048., 73200., 74352., 76092., 77256.,  78420.,  79584.,
      71976., 73152., 74328., 75504., 77268., 78456.,  79644.,  80832.,
      73056., 74256., 75456., 76656., 78444., 79656.,  80868.,  82080.,
      75216., 76464., 77712., 78960., 80796., 82056.,  83316.,  84576.,
      76296., 77568., 78840., 80112., 81972., 83256.,  84540.,  85824.,
      77376., 78672., 79968., 81264., 83148., 84456.,  85764.,  87072.,
      78456., 79776., 81096., 82416., 84324., 85656.,  86988.,  88320.,
      79536., 80880., 82224., 83568., 85500., 86856.,  88212.,  89568.,
      81696., 83088., 84480., 85872., 87852., 89256.,  90660.,  92064.,
      82776., 84192., 85608., 87024., 89028., 90456.,  91884.,  93312.,
      83856., 85296., 86736., 88176., 90204., 91656.,  93108.,  94560.,
      84936., 86400., 87864., 89328., 91380., 92856.,  94332.,  95808.,
      86016., 87504., 88992., 90480., 92556., 94056.,  95556.,  97056.,
      88176., 89712., 91248., 92784., 94908., 96456.,  98004.,  99552.,
      89256., 90816., 92376., 93936., 96084., 97656.,  99228.,  100800.,
      90336., 91920., 93504., 95088., 97260., 98856.,  100452., 102048.,
      91416., 93024., 94632., 96240., 98436., 100056., 101676., 103296.,
      92496., 94128., 95760., 97392., 99612., 101256., 102900., 104544.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2880240., 2900928., 2921712., 2942592., 3607500., 3633360., 3659340.,
      3685440., 4337256., 4368288., 4399464., 4430784., 3619020., 3644880.,
      3670860., 3696960., 2898672., 2919360., 2940144., 2961024., 3657900.,
      3683760., 3709740., 3735840., 4577775., 4610100., 4642575., 4675200.,
      5499330., 5538120., 5577090., 5616240., 4584975., 4617300., 4649775.,
      4682400., 3669420., 3695280., 3721260., 3747360., 4444776., 4475808.,
      4506984., 4538304., 5558130., 5596920., 5635890., 5675040., 6671772.,
      6718320., 6765084., 6812064., 5558130., 5596920., 5635890., 5675040.,
      4444776., 4475808., 4506984., 4538304., 3669420., 3695280., 3721260.,
      3747360., 4584975., 4617300., 4649775., 4682400., 5499330., 5538120.,
      5577090., 5616240., 4577775., 4610100., 4642575., 4675200., 3657900.,
      3683760., 3709740., 3735840., 2898672., 2919360., 2940144., 2961024.,
      3619020., 3644880., 3670860., 3696960., 4337256., 4368288., 4399464.,
      4430784., 3607500., 3633360., 3659340., 3685440., 2880240., 2900928.,
      2921712., 2942592.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      62940., 65136., 67356.,  69600.,  64044., 66288., 68556., 70848.,
      65148., 67440., 69756.,  72096.,  66252., 68592., 70956., 73344.,
      67356., 69744., 72156.,  74592.,  69564., 72048., 74556., 77088.,
      70668., 73200., 75756.,  78336.,  71772., 74352., 76956., 79584.,
      72876., 75504., 78156.,  80832.,  73980., 76656., 79356., 82080.,
      76188., 78960., 81756.,  84576.,  77292., 80112., 82956., 85824.,
      78396., 81264., 84156.,  87072.,  79500., 82416., 85356., 88320.,
      80604., 83568., 86556.,  89568.,  82812., 85872., 88956., 92064.,
      83916., 87024., 90156.,  93312.,  85020., 88176., 91356., 94560.,
      86124., 89328., 92556.,  95808.,  87228., 90480., 93756., 97056.,
      89436., 92784., 96156.,  99552.,  90540., 93936., 97356., 100800.,
      91644., 95088., 98556.,  102048., 92748., 96240., 99756., 103296.,
      93852., 97392., 100956., 104544.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5751504.,  5760480.,  5792832.,  5801856.,  5834352.,  5843424.,
      5876064.,  5885184.,  7203660.,  7215000.,  7255320.,  7266720.,
      7307220.,  7318680.,  7359360.,  7370880.,  8660760.,  8674512.,
      8722752.,  8736576.,  8785032.,  8798928.,  8847600.,  8861568.,
      7226460.,  7238040.,  7278120.,  7289760.,  7330020.,  7341720.,
      7382160.,  7393920.,  5787984.,  5797344.,  5829312.,  5838720.,
      5870832.,  5880288.,  5912544.,  5922048.,  7303860.,  7315800.,
      7355520.,  7367520.,  7407420.,  7419480.,  7459560.,  7471680.,
      9140475.,  9155550.,  9205050.,  9220200.,  9269925.,  9285150.,
      9335100.,  9350400.,  10980390., 10998660., 11057880., 11076240.,
      11135730., 11154180., 11213940., 11232480., 9154575.,  9169950.,
      9219150.,  9234600.,  9284025.,  9299550.,  9349200.,  9364800.,
      7326420.,  7338840.,  7378080.,  7390560.,  7429980.,  7442520.,
      7482120.,  7494720.,  8874360.,  8889552.,  8936352.,  8951616.,
      8998632.,  9013968.,  9061200.,  9076608.,  11097090., 11116260.,
      11174580., 11193840., 11252430., 11271780., 11330640., 11350080.,
      13320324., 13343544., 13413312., 13436640., 13506732., 13530168.,
      13600584., 13624128., 11096730., 11116260., 11174220., 11193840.,
      11252070., 11271780., 11330280., 11350080., 8873784.,  8889552.,
      8935776.,  8951616.,  8998056.,  9013968.,  9060624.,  9076608.,
      7325460.,  7338840.,  7377120.,  7390560.,  7429020.,  7442520.,
      7481160.,  7494720.,  9153075.,  9169950.,  9217650.,  9234600.,
      9282525.,  9299550.,  9347700.,  9364800.,  10978230., 10998660.,
      11055720., 11076240., 11133570., 11154180., 11211780., 11232480.,
      9138375.,  9155550.,  9202950.,  9220200.,  9267825.,  9285150.,
      9333000.,  9350400.,  7301940.,  7315800.,  7353600.,  7367520.,
      7405500.,  7419480.,  7457640.,  7471680.,  5786064.,  5797344.,
      5827392.,  5838720.,  5868912.,  5880288.,  5910624.,  5922048.,
      7223820.,  7238040.,  7275480.,  7289760.,  7327380.,  7341720.,
      7379520.,  7393920.,  8657304.,  8674512.,  8719296.,  8736576.,
      8781576.,  8798928.,  8844144.,  8861568.,  7200540.,  7215000.,
      7252200.,  7266720.,  7304100.,  7318680.,  7356240.,  7370880.,
      5748816.,  5760480.,  5790144.,  5801856.,  5831664.,  5843424.,
      5873376.,  5885184.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      123972., 125880., 128352., 130272., 132780., 134712., 137256., 139200.,
      126132., 128088., 130608., 132576., 135132., 137112., 139704., 141696.,
      128292., 130296., 132864., 134880., 137484., 139512., 142152., 144192.,
      130452., 132504., 135120., 137184., 139836., 141912., 144600., 146688.,
      132612., 134712., 137376., 139488., 142188., 144312., 147048., 149184.,
      136932., 139128., 141888., 144096., 146892., 149112., 151944., 154176.,
      139092., 141336., 144144., 146400., 149244., 151512., 154392., 156672.,
      141252., 143544., 146400., 148704., 151596., 153912., 156840., 159168.,
      143412., 145752., 148656., 151008., 153948., 156312., 159288., 161664.,
      145572., 147960., 150912., 153312., 156300., 158712., 161736., 164160.,
      149892., 152376., 155424., 157920., 161004., 163512., 166632., 169152.,
      152052., 154584., 157680., 160224., 163356., 165912., 169080., 171648.,
      154212., 156792., 159936., 162528., 165708., 168312., 171528., 174144.,
      156372., 159000., 162192., 164832., 168060., 170712., 173976., 176640.,
      158532., 161208., 164448., 167136., 170412., 173112., 176424., 179136.,
      162852., 165624., 168960., 171744., 175116., 177912., 181320., 184128.,
      165012., 167832., 171216., 174048., 177468., 180312., 183768., 186624.,
      167172., 170040., 173472., 176352., 179820., 182712., 186216., 189120.,
      169332., 172248., 175728., 178656., 182172., 185112., 188664., 191616.,
      171492., 174456., 177984., 180960., 184524., 187512., 191112., 194112.,
      175812., 178872., 182496., 185568., 189228., 192312., 196008., 199104.,
      177972., 181080., 184752., 187872., 191580., 194712., 198456., 201600.,
      180132., 183288., 187008., 190176., 193932., 197112., 200904., 204096.,
      182292., 185496., 189264., 192480., 196284., 199512., 203352., 206592.,
      184452., 187704., 191520., 194784., 198636., 201912., 205800., 209088.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4741776.,  4750752.,  4759728.,  4768704.,  4801856.,  4810880.,
      4819904.,  4828928.,  4862320.,  4871392.,  4880464.,  4889536.,
      4923168.,  4932288.,  4941408.,  4950528.,  6000204.,  6011544.,
      6022884.,  6034224.,  6075816.,  6087216.,  6098616.,  6110016.,
      6151908.,  6163368.,  6174828.,  6186288.,  6228480.,  6240000.,
      6251520.,  6263040.,  7247992.,  7261744.,  7275496.,  7289248.,
      7339136.,  7352960.,  7366784.,  7380608.,  7430856.,  7444752.,
      7458648.,  7472544.,  7523152.,  7537120.,  7551088.,  7565056.,
      6148988.,  6160568.,  6172148.,  6183728.,  6225624.,  6237264.,
      6248904.,  6260544.,  6302740.,  6314440.,  6326140.,  6337840.,
      6380336.,  6392096.,  6403856.,  6415616.,  5066256.,  5075616.,
      5084976.,  5094336.,  5128384.,  5137792.,  5147200.,  5156608.,
      5190896.,  5200352.,  5209808.,  5219264.,  5253792.,  5263296.,
      5272800.,  5282304.,  6094532.,  6106472.,  6118412.,  6130352.,
      6171168.,  6183168.,  6195168.,  6207168.,  6248284.,  6260344.,
      6272404.,  6284464.,  6325880.,  6338000.,  6350120.,  6362240.,
      7685907.,  7700982.,  7716057.,  7731132.,  7782214.,  7797364.,
      7812514.,  7827664.,  7879121.,  7894346.,  7909571.,  7924796.,
      7976628.,  7991928.,  8007228.,  8022528.,  9259246.,  9277516.,
      9295786.,  9314056.,  9375224.,  9393584.,  9411944.,  9430304.,
      9491922.,  9510372.,  9528822.,  9547272.,  9609340.,  9627880.,
      9646420.,  9664960.,  7821327.,  7836702.,  7852077.,  7867452.,
      7918658.,  7934108.,  7949558.,  7965008.,  8016589.,  8032114.,
      8047639.,  8063164.,  8115120.,  8130720.,  8146320.,  8161920.,
      6407460.,  6419880.,  6432300.,  6444720.,  6486144.,  6498624.,
      6511104.,  6523584.,  6565308.,  6577848.,  6590388.,  6602928.,
      6644952.,  6657552.,  6670152.,  6682752.,  7384984.,  7400176.,
      7415368.,  7430560.,  7478176.,  7493440.,  7508704.,  7523968.,
      7571944.,  7587280.,  7602616.,  7617952.,  7666288.,  7681696.,
      7697104.,  7712512.,  9287970.,  9307140.,  9326310.,  9345480.,
      9404972.,  9424232.,  9443492.,  9462752.,  9522694.,  9542044.,
      9561394.,  9580744.,  9641136.,  9660576.,  9680016.,  9699456.,
      11163220., 11186440., 11209660., 11232880., 11304032., 11327360.,
      11350688., 11374016., 11445708., 11469144., 11492580., 11516016.,
      11588248., 11611792., 11635336., 11658880., 9398506.,  9418036.,
      9437566.,  9457096.,  9516532.,  9536152.,  9555772.,  9575392.,
      9635278.,  9654988.,  9674698.,  9694408.,  9754744.,  9774544.,
      9794344.,  9814144.,  7667928.,  7683696.,  7699464.,  7715232.,
      7763168.,  7779008.,  7794848.,  7810688.,  7858984.,  7874896.,
      7890808.,  7906720.,  7955376.,  7971360.,  7987344.,  8003328.,
      6558180.,  6571560.,  6584940.,  6598320.,  6638912.,  6652352.,
      6665792.,  6679232.,  6720124.,  6733624.,  6747124.,  6760624.,
      6801816.,  6815376.,  6828936.,  6842496.,  8271483.,  8288358.,
      8305233.,  8322108.,  8372910.,  8389860.,  8406810.,  8423760.,
      8474937.,  8491962.,  8508987.,  8526012.,  8577564.,  8594664.,
      8611764.,  8628864.,  9959326.,  9979756.,  10000186., 10020616.,
      10081448., 10101968., 10122488., 10143008., 10204290., 10224900.,
      10245510., 10266120., 10327852., 10348552., 10369252., 10389952.,
      8418935.,  8436110.,  8453285.,  8470460.,  8521386.,  8538636.,
      8555886.,  8573136.,  8624437.,  8641762.,  8659087.,  8676412.,
      8728088.,  8745488.,  8762888.,  8780288.,  6910020.,  6923880.,
      6937740.,  6951600.,  6992800.,  7006720.,  7020640.,  7034560.,
      7076060.,  7090040.,  7104020.,  7118000.,  7159800.,  7173840.,
      7187880.,  7201920.,  5351312.,  5362592.,  5373872.,  5385152.,
      5417536.,  5428864.,  5440192.,  5451520.,  5484144.,  5495520.,
      5506896.,  5518272.,  5551136.,  5562560.,  5573984.,  5585408.,
      6630540.,  6644760.,  6658980.,  6673200.,  6713320.,  6727600.,
      6741880.,  6756160.,  6796580.,  6810920.,  6825260.,  6839600.,
      6880320.,  6894720.,  6909120.,  6923520.,  7884792.,  7902000.,
      7919208.,  7936416.,  7984128.,  8001408.,  8018688.,  8035968.,
      8084040.,  8101392.,  8118744.,  8136096.,  8184528.,  8201952.,
      8219376.,  8236800.,  6501820.,  6516280.,  6530740.,  6545200.,
      6584600.,  6599120.,  6613640.,  6628160.,  6667860.,  6682440.,
      6697020.,  6711600.,  6751600.,  6766240.,  6780880.,  6795520.,
      5145360.,  5157024.,  5168688.,  5180352.,  5211584.,  5223296.,
      5235008.,  5246720.,  5278192.,  5289952.,  5301712.,  5313472.,
      5345184.,  5356992.,  5368800.,  5380608.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      246036., 247944., 249852., 251760., 254784., 256704., 258624., 260544.,
      263628., 265560., 267492., 269424., 272568., 274512., 276456., 278400.,
      250308., 252264., 254220., 256176., 259248., 261216., 263184., 265152.,
      268284., 270264., 272244., 274224., 277416., 279408., 281400., 283392.,
      254580., 256584., 258588., 260592., 263712., 265728., 267744., 269760.,
      272940., 274968., 276996., 279024., 282264., 284304., 286344., 288384.,
      258852., 260904., 262956., 265008., 268176., 270240., 272304., 274368.,
      277596., 279672., 281748., 283824., 287112., 289200., 291288., 293376.,
      263124., 265224., 267324., 269424., 272640., 274752., 276864., 278976.,
      282252., 284376., 286500., 288624., 291960., 294096., 296232., 298368.,
      271668., 273864., 276060., 278256., 281568., 283776., 285984., 288192.,
      291564., 293784., 296004., 298224., 301656., 303888., 306120., 308352.,
      275940., 278184., 280428., 282672., 286032., 288288., 290544., 292800.,
      296220., 298488., 300756., 303024., 306504., 308784., 311064., 313344.,
      280212., 282504., 284796., 287088., 290496., 292800., 295104., 297408.,
      300876., 303192., 305508., 307824., 311352., 313680., 316008., 318336.,
      284484., 286824., 289164., 291504., 294960., 297312., 299664., 302016.,
      305532., 307896., 310260., 312624., 316200., 318576., 320952., 323328.,
      288756., 291144., 293532., 295920., 299424., 301824., 304224., 306624.,
      310188., 312600., 315012., 317424., 321048., 323472., 325896., 328320.,
      297300., 299784., 302268., 304752., 308352., 310848., 313344., 315840.,
      319500., 322008., 324516., 327024., 330744., 333264., 335784., 338304.,
      301572., 304104., 306636., 309168., 312816., 315360., 317904., 320448.,
      324156., 326712., 329268., 331824., 335592., 338160., 340728., 343296.,
      305844., 308424., 311004., 313584., 317280., 319872., 322464., 325056.,
      328812., 331416., 334020., 336624., 340440., 343056., 345672., 348288.,
      310116., 312744., 315372., 318000., 321744., 324384., 327024., 329664.,
      333468., 336120., 338772., 341424., 345288., 347952., 350616., 353280.,
      314388., 317064., 319740., 322416., 326208., 328896., 331584., 334272.,
      338124., 340824., 343524., 346224., 350136., 352848., 355560., 358272.,
      322932., 325704., 328476., 331248., 335136., 337920., 340704., 343488.,
      347436., 350232., 353028., 355824., 359832., 362640., 365448., 368256.,
      327204., 330024., 332844., 335664., 339600., 342432., 345264., 348096.,
      352092., 354936., 357780., 360624., 364680., 367536., 370392., 373248.,
      331476., 334344., 337212., 340080., 344064., 346944., 349824., 352704.,
      356748., 359640., 362532., 365424., 369528., 372432., 375336., 378240.,
      335748., 338664., 341580., 344496., 348528., 351456., 354384., 357312.,
      361404., 364344., 367284., 370224., 374376., 377328., 380280., 383232.,
      340020., 342984., 345948., 348912., 352992., 355968., 358944., 361920.,
      366060., 369048., 372036., 375024., 379224., 382224., 385224., 388224.,
      348564., 351624., 354684., 357744., 361920., 364992., 368064., 371136.,
      375372., 378456., 381540., 384624., 388920., 392016., 395112., 398208.,
      352836., 355944., 359052., 362160., 366384., 369504., 372624., 375744.,
      380028., 383160., 386292., 389424., 393768., 396912., 400056., 403200.,
      357108., 360264., 363420., 366576., 370848., 374016., 377184., 380352.,
      384684., 387864., 391044., 394224., 398616., 401808., 405000., 408192.,
      361380., 364584., 367788., 370992., 375312., 378528., 381744., 384960.,
      389340., 392568., 395796., 399024., 403464., 406704., 409944., 413184.,
      365652., 368904., 372156., 375408., 379776., 383040., 386304., 389568.,
      393996., 397272., 400548., 403824., 408312., 411600., 414888., 418176.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      312450., 375564., 438858., 376572., 314130., 396600., 476385.,
      556290., 477015., 397650., 481695., 578214., 674751., 578214.,
      481695., 397650., 477015., 556290., 476385., 396600., 314130.,
      376572., 438858., 375564., 312450.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11253., 11424., 11595., 11766., 11937., 12450., 12621., 12792., 12963.,
      13134., 13647., 13818., 13989., 14160., 14331., 14844., 15015., 15186.,
      15357., 15528., 16041., 16212., 16383., 16554., 16725.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      621570.,  624900.,  747096.,  751128.,  872970.,  877716.,  749040.,
      753144.,  624810.,  628260.,  788775.,  793200.,  947415.,  952770.,
      1106280., 1112580., 948585.,  954030.,  790725.,  795300.,  957765.,
      963390.,  1149624., 1156428., 1341501., 1349502., 1149516., 1156428.,
      957585.,  963390.,  790350.,  795300.,  948045.,  954030.,  1105545.,
      1112580., 946695.,  952770.,  788100.,  793200.,  624090.,  628260.,
      748104.,  753144.,  871794.,  877716.,  746016.,  751128.,  620610.,
      624900.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21651., 22506., 21975., 22848., 22299., 23190., 22623., 23532., 22947.,
      23874., 23919., 24900., 24243., 25242., 24567., 25584., 24891., 25926.,
      25215., 26268., 26187., 27294., 26511., 27636., 26835., 27978., 27159.,
      28320., 27483., 28662., 28455., 29688., 28779., 30030., 29103., 30372.,
      29427., 30714., 29751., 31056., 30723., 32082., 31047., 32424., 31371.,
      32766., 31695., 33108., 32019., 33450.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1239810., 1243140., 1246470., 1249800., 1490160., 1494192., 1498224.,
      1502256., 1741194., 1745940., 1750686., 1755432., 1493976., 1498080.,
      1502184., 1506288., 1246170., 1249620., 1253070., 1256520., 1573125.,
      1577550., 1581975., 1586400., 1889475., 1894830., 1900185., 1905540.,
      2206260., 2212560., 2218860., 2225160., 1891725., 1897170., 1902615.,
      1908060., 1576875., 1581450., 1586025., 1590600., 1909905., 1915530.,
      1921155., 1926780., 2292444., 2299248., 2306052., 2312856., 2675001.,
      2683002., 2691003., 2699004., 2292120., 2299032., 2305944., 2312856.,
      1909365., 1915170., 1920975., 1926780., 1575750., 1580700., 1585650.,
      1590600., 1890105., 1896090., 1902075., 1908060., 2204055., 2211090.,
      2218125., 2225160., 1887315., 1893390., 1899465., 1905540., 1571100.,
      1576200., 1581300., 1586400., 1244010., 1248180., 1252350., 1256520.,
      1491168., 1496208., 1501248., 1506288., 1737666., 1743588., 1749510.,
      1755432., 1486920., 1492032., 1497144., 1502256., 1236930., 1241220.,
      1245510., 1249800.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42447., 43302., 44157., 45012., 43077., 43950., 44823., 45696., 43707.,
      44598., 45489., 46380., 44337., 45246., 46155., 47064., 44967., 45894.,
      46821., 47748., 46857., 47838., 48819., 49800., 47487., 48486., 49485.,
      50484., 48117., 49134., 50151., 51168., 48747., 49782., 50817., 51852.,
      49377., 50430., 51483., 52536., 51267., 52374., 53481., 54588., 51897.,
      53022., 54147., 55272., 52527., 53670., 54813., 55956., 53157., 54318.,
      55479., 56640., 53787., 54966., 56145., 57324., 55677., 56910., 58143.,
      59376., 56307., 57558., 58809., 60060., 56937., 58206., 59475., 60744.,
      57567., 58854., 60141., 61428., 58197., 59502., 60807., 62112., 60087.,
      61446., 62805., 64164., 60717., 62094., 63471., 64848., 61347., 62742.,
      64137., 65532., 61977., 63390., 64803., 66216., 62607., 64038., 65469.,
      66900.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1234620., 1249800., 1484040., 1502256., 1734180., 1755432., 1488072.,
      1506288., 1241340., 1256520., 1567425., 1586400., 1882770., 1905540.,
      2198595., 2225160., 1885290., 1908060., 1571625., 1590600., 1904010.,
      1926780., 2285532., 2312856., 2667126., 2699004., 2285532., 2312856.,
      1904010., 1926780., 1571625., 1590600., 1885290., 1908060., 2198595.,
      2225160., 1882770., 1905540., 1567425., 1586400., 1241340., 1256520.,
      1488072., 1506288., 1734180., 1755432., 1484040., 1502256., 1234620.,
      1249800.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42978., 45012., 43626., 45696., 44274., 46380., 44922., 47064., 45570.,
      47748., 47514., 49800., 48162., 50484., 48810., 51168., 49458., 51852.,
      50106., 52536., 52050., 54588., 52698., 55272., 53346., 55956., 53994.,
      56640., 54642., 57324., 56586., 59376., 57234., 60060., 57882., 60744.,
      58530., 61428., 59178., 62112., 61122., 64164., 61770., 64848., 62418.,
      65532., 63066., 66216., 63714., 66900.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2462640., 2469240., 2492940., 2499600., 2960088., 2968080., 2996448.,
      3004512., 3458952., 3468360., 3501372., 3510864., 2968008., 2976144.,
      3004368., 3012576., 2475840., 2482680., 2506140., 2513040., 3126075.,
      3134850., 3163950., 3172800., 3754920., 3765540., 3800370., 3811080.,
      4384695., 4397190., 4437720., 4450320., 3759780., 3770580., 3805230.,
      3816120., 3134175., 3143250., 3172050., 3181200., 3796860., 3808020.,
      3842310., 3853560., 4557564., 4571064., 4612104., 4625712., 5318376.,
      5334252., 5382006., 5398008., 4557348., 4571064., 4611888., 4625712.,
      3796500., 3808020., 3841950., 3853560., 3133425., 3143250., 3171300.,
      3181200., 3758700., 3770580., 3804150., 3816120., 4383225., 4397190.,
      4436250., 4450320., 3753480., 3765540., 3798930., 3811080., 3124725.,
      3134850., 3162600., 3172800., 2474400., 2482680., 2504700., 2513040.,
      2966136., 2976144., 3002496., 3012576., 3456600., 3468360., 3499020.,
      3510864., 2957928., 2968080., 2994288., 3004512., 2460720., 2469240.,
      2491020., 2499600.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84264.,  85956.,  88314.,  90024.,  85524.,  87252.,  89646.,  91392.,
      86784.,  88548.,  90978.,  92760.,  88044.,  89844.,  92310.,  94128.,
      89304.,  91140.,  93642.,  95496.,  93084.,  95028.,  97638.,  99600.,
      94344.,  96324.,  98970.,  100968., 95604.,  97620.,  100302., 102336.,
      96864.,  98916.,  101634., 103704., 98124.,  100212., 102966., 105072.,
      101904., 104100., 106962., 109176., 103164., 105396., 108294., 110544.,
      104424., 106692., 109626., 111912., 105684., 107988., 110958., 113280.,
      106944., 109284., 112290., 114648., 110724., 113172., 116286., 118752.,
      111984., 114468., 117618., 120120., 113244., 115764., 118950., 121488.,
      114504., 117060., 120282., 122856., 115764., 118356., 121614., 124224.,
      119544., 122244., 125610., 128328., 120804., 123540., 126942., 129696.,
      122064., 124836., 128274., 131064., 123324., 126132., 129606., 132432.,
      124584., 127428., 130938., 133800.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4918680.,  4925280.,  4931880.,  4938480.,  4979220.,  4985880.,
      4992540.,  4999200.,  5912184.,  5920176.,  5928168.,  5936160.,
      5984832.,  5992896.,  6000960.,  6009024.,  6908496.,  6917904.,
      6927312.,  6936720.,  6993252.,  7002744.,  7012236.,  7021728.,
      5927880.,  5936016.,  5944152.,  5952288.,  6000528.,  6008736.,
      6016944.,  6025152.,  4944840.,  4951680.,  4958520.,  4965360.,
      5005380.,  5012280.,  5019180.,  5026080.,  6243375.,  6252150.,
      6260925.,  6269700.,  6319050.,  6327900.,  6336750.,  6345600.,
      7499220.,  7509840.,  7520460.,  7531080.,  7590030.,  7600740.,
      7611450.,  7622160.,  8756895.,  8769390.,  8781885.,  8794380.,
      8862840.,  8875440.,  8888040.,  8900640.,  7508760.,  7519560.,
      7530360.,  7541160.,  7599570.,  7610460.,  7621350.,  7632240.,
      6259275.,  6268350.,  6277425.,  6286500.,  6334950.,  6344100.,
      6353250.,  6362400.,  7582560.,  7593720.,  7604880.,  7616040.,
      7673370.,  7684620.,  7695870.,  7707120.,  9101628.,  9115128.,
      9128628.,  9142128.,  9210600.,  9224208.,  9237816.,  9251424.,
      10620876., 10636752., 10652628., 10668504., 10748010., 10764012.,
      10780014., 10796016., 9100980.,  9114696.,  9128412.,  9142128.,
      9209952.,  9223776.,  9237600.,  9251424.,  7581480.,  7593000.,
      7604520.,  7616040.,  7672290.,  7683900.,  7695510.,  7707120.,
      6257025.,  6266850.,  6276675.,  6286500.,  6332700.,  6342600.,
      6352500.,  6362400.,  7505520.,  7517400.,  7529280.,  7541160.,
      7596330.,  7608300.,  7620270.,  7632240.,  8752485.,  8766450.,
      8780415.,  8794380.,  8858430.,  8872500.,  8886570.,  8900640.,
      7494900.,  7506960.,  7519020.,  7531080.,  7585710.,  7597860.,
      7610010.,  7622160.,  6239325.,  6249450.,  6259575.,  6269700.,
      6315000.,  6325200.,  6335400.,  6345600.,  4940520.,  4948800.,
      4957080.,  4965360.,  5001060.,  5009400.,  5017740.,  5026080.,
      5922264.,  5932272.,  5942280.,  5952288.,  5994912.,  6004992.,
      6015072.,  6025152.,  6901440.,  6913200.,  6924960.,  6936720.,
      6986196.,  6998040.,  7009884.,  7021728.,  5905704.,  5915856.,
      5926008.,  5936160.,  5978352.,  5988576.,  5998800.,  6009024.,
      4912920.,  4921440.,  4929960.,  4938480.,  4973460.,  4982040.,
      4990620.,  4999200.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      166836., 168528., 170220., 171912., 174918., 176628., 178338., 180048.,
      169320., 171048., 172776., 174504., 177546., 179292., 181038., 182784.,
      171804., 173568., 175332., 177096., 180174., 181956., 183738., 185520.,
      174288., 176088., 177888., 179688., 182802., 184620., 186438., 188256.,
      176772., 178608., 180444., 182280., 185430., 187284., 189138., 190992.,
      184224., 186168., 188112., 190056., 193314., 195276., 197238., 199200.,
      186708., 188688., 190668., 192648., 195942., 197940., 199938., 201936.,
      189192., 191208., 193224., 195240., 198570., 200604., 202638., 204672.,
      191676., 193728., 195780., 197832., 201198., 203268., 205338., 207408.,
      194160., 196248., 198336., 200424., 203826., 205932., 208038., 210144.,
      201612., 203808., 206004., 208200., 211710., 213924., 216138., 218352.,
      204096., 206328., 208560., 210792., 214338., 216588., 218838., 221088.,
      206580., 208848., 211116., 213384., 216966., 219252., 221538., 223824.,
      209064., 211368., 213672., 215976., 219594., 221916., 224238., 226560.,
      211548., 213888., 216228., 218568., 222222., 224580., 226938., 229296.,
      219000., 221448., 223896., 226344., 230106., 232572., 235038., 237504.,
      221484., 223968., 226452., 228936., 232734., 235236., 237738., 240240.,
      223968., 226488., 229008., 231528., 235362., 237900., 240438., 242976.,
      226452., 229008., 231564., 234120., 237990., 240564., 243138., 245712.,
      228936., 231528., 234120., 236712., 240618., 243228., 245838., 248448.,
      236388., 239088., 241788., 244488., 248502., 251220., 253938., 256656.,
      238872., 241608., 244344., 247080., 251130., 253884., 256638., 259392.,
      241356., 244128., 246900., 249672., 253758., 256548., 259338., 262128.,
      243840., 246648., 249456., 252264., 256386., 259212., 262038., 264864.,
      246324., 249168., 252012., 254856., 259014., 261876., 264738., 267600.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4908300.,  4938480.,  4968780.,  4999200., 5899944., 5936160., 5972520.,
      6009024.,  6894468.,  6936720.,  6979140., 7021728., 5916072., 5952288.,
      5988648.,  6025152.,  4935180.,  4965360., 4995660., 5026080., 6231975.,
      6269700.,  6307575.,  6345600.,  7485810., 7531080., 7576530., 7622160.,
      8741565.,  8794380.,  8847405.,  8900640., 7495890., 7541160., 7586610.,
      7632240.,  6248775.,  6286500.,  6324375., 6362400., 7570770., 7616040.,
      7661490.,  7707120.,  9087804.,  9142128., 9196668., 9251424., 10605126.,
      10668504., 10732134., 10796016., 9087804., 9142128., 9196668., 9251424.,
      7570770.,  7616040.,  7661490.,  7707120., 6248775., 6286500., 6324375.,
      6362400.,  7495890.,  7541160.,  7586610., 7632240., 8741565., 8794380.,
      8847405.,  8900640.,  7485810.,  7531080., 7576530., 7622160., 6231975.,
      6269700.,  6307575.,  6345600.,  4935180., 4965360., 4995660., 5026080.,
      5916072.,  5952288.,  5988648.,  6025152., 6894468., 6936720., 6979140.,
      7021728.,  5899944.,  5936160.,  5972520., 6009024., 4908300., 4938480.,
      4968780.,  4999200.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      167898., 171912., 175962., 180048., 170418., 174504., 178626., 182784.,
      172938., 177096., 181290., 185520., 175458., 179688., 183954., 188256.,
      177978., 182280., 186618., 190992., 185538., 190056., 194610., 199200.,
      188058., 192648., 197274., 201936., 190578., 195240., 199938., 204672.,
      193098., 197832., 202602., 207408., 195618., 200424., 205266., 210144.,
      203178., 208200., 213258., 218352., 205698., 210792., 215922., 221088.,
      208218., 213384., 218586., 223824., 210738., 215976., 221250., 226560.,
      213258., 218568., 223914., 229296., 220818., 226344., 231906., 237504.,
      223338., 228936., 234570., 240240., 225858., 231528., 237234., 242976.,
      228378., 234120., 239898., 245712., 230898., 236712., 242562., 248448.,
      238458., 244488., 250554., 256656., 240978., 247080., 253218., 259392.,
      243498., 249672., 255882., 262128., 246018., 252264., 258546., 264864.,
      248538., 254856., 261210., 267600.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4051140., 4064280., 4093520., 4106720., 4136140., 4149400., 4179000.,
      4192320., 4838184., 4854096., 4889040., 4905024., 4940184., 4956240.,
      4991616., 5007744., 5717468., 5736200., 5777312., 5796128., 5837492.,
      5856392., 5898008., 5916992., 4887048., 4903248., 4938416., 4954688.,
      4990072., 5006416., 5042016., 5058432., 4066020., 4079640., 4108912.,
      4122592., 4152044., 4165784., 4195416., 4209216., 5309195., 5326670.,
      5364090., 5381640., 5419285., 5436910., 5474780., 5492480., 6336582.,
      6357732., 6402456., 6423696., 6468690., 6490020., 6535284., 6556704.,
      7466565., 7491450., 7543930., 7568920., 7621715., 7646810., 7699920.,
      7725120., 6375326., 6396836., 6441712., 6463312., 6508458., 6530148.,
      6575564., 6597344., 5297651., 5315726., 5353058., 5371208., 5408765.,
      5426990., 5464772., 5483072., 6525390., 6547620., 6592800., 6615120.,
      6660570., 6682980., 6728700., 6751200., 7780716., 7807608., 7861608.,
      7888608., 7942932., 7970040., 8024688., 8051904., 9147650., 9179276.,
      9242536., 9274288., 9337926., 9369804., 9433820., 9465824., 7801276.,
      7828600., 7882680., 7910112., 7964516., 7992056., 8046784., 8074432.,
      6473982., 6496932., 6541904., 6564944., 6610186., 6633316., 6678828.,
      6702048., 5435415., 5454990., 5492870., 5512520., 5550625., 5570350.,
      5608680., 5628480., 6474030., 6497700., 6542976., 6566736., 6612282.,
      6636132., 6681948., 6705888., 7639241., 7667066., 7720190., 7748120.,
      7801559., 7829594., 7883348., 7911488., 6513414., 6537444., 6582872.,
      6606992., 6652690., 6676900., 6722868., 6747168., 5405823., 5425998.,
      5463790., 5484040., 5522057., 5542382., 5580624., 5601024., 4506020.,
      4522520., 4553520., 4570080., 4601260., 4617880., 4649240., 4665920.,
      5364072., 5384016., 5421072., 5441088., 5478360., 5498448., 5535936.,
      5556096., 6365052., 6388488., 6432064., 6455584., 6499412., 6523016.,
      6567096., 6590784., 5430344., 5450576., 5487856., 5508160., 5545656.,
      5566032., 5603744., 5624192., 4511684., 4528664., 4559696., 4576736.,
      4607948., 4625048., 4656440., 4673600.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      332430., 335796., 340440., 343824., 348522., 351924., 356676., 360096.,
      337398., 340836., 345552., 349008., 353778., 357252., 362076., 365568.,
      342366., 345876., 350664., 354192., 359034., 362580., 367476., 371040.,
      347334., 350916., 355776., 359376., 364290., 367908., 372876., 376512.,
      352302., 355956., 360888., 364560., 369546., 373236., 378276., 381984.,
      367206., 371076., 376224., 380112., 385314., 389220., 394476., 398400.,
      372174., 376116., 381336., 385296., 390570., 394548., 399876., 403872.,
      377142., 381156., 386448., 390480., 395826., 399876., 405276., 409344.,
      382110., 386196., 391560., 395664., 401082., 405204., 410676., 414816.,
      387078., 391236., 396672., 400848., 406338., 410532., 416076., 420288.,
      401982., 406356., 412008., 416400., 422106., 426516., 432276., 436704.,
      406950., 411396., 417120., 421584., 427362., 431844., 437676., 442176.,
      411918., 416436., 422232., 426768., 432618., 437172., 443076., 447648.,
      416886., 421476., 427344., 431952., 437874., 442500., 448476., 453120.,
      421854., 426516., 432456., 437136., 443130., 447828., 453876., 458592.,
      436758., 441636., 447792., 452688., 458898., 463812., 470076., 475008.,
      441726., 446676., 452904., 457872., 464154., 469140., 475476., 480480.,
      446694., 451716., 458016., 463056., 469410., 474468., 480876., 485952.,
      451662., 456756., 463128., 468240., 474666., 479796., 486276., 491424.,
      456630., 461796., 468240., 473424., 479922., 485124., 491676., 496896.,
      471534., 476916., 483576., 488976., 495690., 501108., 507876., 513312.,
      476502., 481956., 488688., 494160., 500946., 506436., 513276., 518784.,
      481470., 486996., 493800., 499344., 506202., 511764., 518676., 524256.,
      486438., 492036., 498912., 504528., 511458., 517092., 524076., 529728.,
      491406., 497076., 504024., 509712., 516714., 522420., 529476., 535200.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3329076., 3342216., 3355356., 3368496., 3396880., 3410080., 3423280.,
      3436480., 3465164., 3478424., 3491684., 3504944., 3533928., 3547248.,
      3560568., 3573888., 3926568., 3942480., 3958392., 3974304., 4008240.,
      4024224., 4040208., 4056192., 4090488., 4106544., 4122600., 4138656.,
      4173312., 4189440., 4205568., 4221696., 4595340., 4614072., 4632804.,
      4651536., 4691392., 4710208., 4729024., 4747840., 4788116., 4807016.,
      4825916., 4844816., 4885512., 4904496., 4923480., 4942464., 3878600.,
      3894800., 3911000., 3927200., 3961296., 3977568., 3993840., 4010112.,
      4044568., 4060912., 4077256., 4093600., 4128416., 4144832., 4161248.,
      4177664., 3195028., 3208648., 3222268., 3235888., 3264368., 3278048.,
      3291728., 3305408., 3334188., 3347928., 3361668., 3375408., 3404488.,
      3418288., 3432088., 3445888., 4555219., 4572694., 4590169., 4607644.,
      4644454., 4662004., 4679554., 4697104., 4734289., 4751914., 4769539.,
      4787164., 4824724., 4842424., 4860124., 4877824., 5445614., 5466764.,
      5487914., 5509064., 5553208., 5574448., 5595688., 5616928., 5661522.,
      5682852., 5704182., 5725512., 5770556., 5791976., 5813396., 5834816.,
      6411605., 6436490., 6461375., 6486260., 6538070., 6563060., 6588050.,
      6613040., 6665375., 6690470., 6715565., 6740660., 6793520., 6818720.,
      6843920., 6869120., 5543734., 5565244., 5586754., 5608264., 5652864.,
      5674464., 5696064., 5717664., 5762714., 5784404., 5806094., 5827784.,
      5873284., 5895064., 5916844., 5938624., 4721483., 4739558., 4757633.,
      4775708., 4813278., 4831428., 4849578., 4867728., 4905673., 4923898.,
      4942123., 4960348., 4998668., 5016968., 5035268., 5053568., 5956294.,
      5978524., 6000754., 6022984., 6067984., 6090304., 6112624., 6134944.,
      6180394., 6202804., 6225214., 6247624., 6293524., 6316024., 6338524.,
      6361024., 7104460., 7131352., 7158244., 7185136., 7239000., 7266000.,
      7293000., 7320000., 7374404., 7401512., 7428620., 7455728., 7510672.,
      7537888., 7565104., 7592320., 8329850., 8361476., 8393102., 8424728.,
      8487752., 8519504., 8551256., 8583008., 8646662., 8678540., 8710418.,
      8742296., 8806580., 8838584., 8870588., 8902592., 7168188., 7195512.,
      7222836., 7250160., 7304264., 7331696., 7359128., 7386560., 7441204.,
      7468744., 7496284., 7523824., 7579008., 7606656., 7634304., 7661952.,
      6065238., 6088188., 6111138., 6134088., 6179488., 6202528., 6225568.,
      6248608., 6294458., 6317588., 6340718., 6363848., 6410148., 6433368.,
      6456588., 6479808., 4900279., 4919854., 4939429., 4959004., 4997194.,
      5016844., 5036494., 5056144., 5094709., 5114434., 5134159., 5153884.,
      5192824., 5212624., 5232424., 5252224., 5866470., 5890140., 5913810.,
      5937480., 5983280., 6007040., 6030800., 6054560., 6100810., 6124660.,
      6148510., 6172360., 6219060., 6243000., 6266940., 6290880., 6929633.,
      6957458., 6985283., 7013108., 7066850., 7094780., 7122710., 7150640.,
      7204907., 7232942., 7260977., 7289012., 7343804., 7371944., 7400084.,
      7428224., 6006830., 6030860., 6054890., 6078920., 6125176., 6149296.,
      6173416., 6197536., 6244242., 6268452., 6292662., 6316872., 6364028.,
      6388328., 6412628., 6436928., 5136943., 5157118., 5177293., 5197468.,
      5236418., 5256668., 5276918., 5297168., 5336493., 5356818., 5377143.,
      5397468., 5437168., 5457568., 5477968., 5498368., 4134100., 4150600.,
      4167100., 4183600., 4215216., 4231776., 4248336., 4264896., 4296812.,
      4313432., 4330052., 4346672., 4378888., 4395568., 4412248., 4428928.,
      4928744., 4948688., 4968632., 4988576., 5026288., 5046304., 5066320.,
      5086336., 5124408., 5144496., 5164584., 5184672., 5223104., 5243264.,
      5263424., 5283584., 5840748., 5864184., 5887620., 5911056., 5955232.,
      5978752., 6002272., 6025792., 6070388., 6093992., 6117596., 6141200.,
      6186216., 6209904., 6233592., 6257280., 5061000., 5081232., 5101464.,
      5121696., 5159568., 5179872., 5200176., 5220480., 5258712., 5279088.,
      5299464., 5319840., 5358432., 5378880., 5399328., 5419776., 4325684.,
      4342664., 4359644., 4376624., 4408336., 4425376., 4442416., 4459456.,
      4491468., 4508568., 4525668., 4542768., 4575080., 4592240., 4609400.,
      4626560.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      661494.,  664860.,  668226.,  671592.,  677496.,  680880.,  684264.,
      687648.,  693642.,  697044.,  700446.,  703848.,  709932.,  713352.,
      716772.,  720192.,  671358.,  674796.,  678234.,  681672.,  687648.,
      691104.,  694560.,  698016.,  704082.,  707556.,  711030.,  714504.,
      720660.,  724152.,  727644.,  731136.,  681222.,  684732.,  688242.,
      691752.,  697800.,  701328.,  704856.,  708384.,  714522.,  718068.,
      721614.,  725160.,  731388.,  734952.,  738516.,  742080.,  691086.,
      694668.,  698250.,  701832.,  707952.,  711552.,  715152.,  718752.,
      724962.,  728580.,  732198.,  735816.,  742116.,  745752.,  749388.,
      753024.,  700950.,  704604.,  708258.,  711912.,  718104.,  721776.,
      725448.,  729120.,  735402.,  739092.,  742782.,  746472.,  752844.,
      756552.,  760260.,  763968.,  730542.,  734412.,  738282.,  742152.,
      748560.,  752448.,  756336.,  760224.,  766722.,  770628.,  774534.,
      778440.,  785028.,  788952.,  792876.,  796800.,  740406.,  744348.,
      748290.,  752232.,  758712.,  762672.,  766632.,  770592.,  777162.,
      781140.,  785118.,  789096.,  795756.,  799752.,  803748.,  807744.,
      750270.,  754284.,  758298.,  762312.,  768864.,  772896.,  776928.,
      780960.,  787602.,  791652.,  795702.,  799752.,  806484.,  810552.,
      814620.,  818688.,  760134.,  764220.,  768306.,  772392.,  779016.,
      783120.,  787224.,  791328.,  798042.,  802164.,  806286.,  810408.,
      817212.,  821352.,  825492.,  829632.,  769998.,  774156.,  778314.,
      782472.,  789168.,  793344.,  797520.,  801696.,  808482.,  812676.,
      816870.,  821064.,  827940.,  832152.,  836364.,  840576.,  799590.,
      803964.,  808338.,  812712.,  819624.,  824016.,  828408.,  832800.,
      839802.,  844212.,  848622.,  853032.,  860124.,  864552.,  868980.,
      873408.,  809454.,  813900.,  818346.,  822792.,  829776.,  834240.,
      838704.,  843168.,  850242.,  854724.,  859206.,  863688.,  870852.,
      875352.,  879852.,  884352.,  819318.,  823836.,  828354.,  832872.,
      839928.,  844464.,  849000.,  853536.,  860682.,  865236.,  869790.,
      874344.,  881580.,  886152.,  890724.,  895296.,  829182.,  833772.,
      838362.,  842952.,  850080.,  854688.,  859296.,  863904.,  871122.,
      875748.,  880374.,  885000.,  892308.,  896952.,  901596.,  906240.,
      839046.,  843708.,  848370.,  853032.,  860232.,  864912.,  869592.,
      874272.,  881562.,  886260.,  890958.,  895656.,  903036.,  907752.,
      912468.,  917184.,  868638.,  873516.,  878394.,  883272.,  890688.,
      895584.,  900480.,  905376.,  912882.,  917796.,  922710.,  927624.,
      935220.,  940152.,  945084.,  950016.,  878502.,  883452.,  888402.,
      893352.,  900840.,  905808.,  910776.,  915744.,  923322.,  928308.,
      933294.,  938280.,  945948.,  950952.,  955956.,  960960.,  888366.,
      893388.,  898410.,  903432.,  910992.,  916032.,  921072.,  926112.,
      933762.,  938820.,  943878.,  948936.,  956676.,  961752.,  966828.,
      971904.,  898230.,  903324.,  908418.,  913512.,  921144.,  926256.,
      931368.,  936480.,  944202.,  949332.,  954462.,  959592.,  967404.,
      972552.,  977700.,  982848.,  908094.,  913260.,  918426.,  923592.,
      931296.,  936480.,  941664.,  946848.,  954642.,  959844.,  965046.,
      970248.,  978132.,  983352.,  988572.,  993792.,  937686.,  943068.,
      948450.,  953832.,  961752.,  967152.,  972552.,  977952.,  985962.,
      991380.,  996798.,  1002216., 1010316., 1015752., 1021188., 1026624.,
      947550.,  953004.,  958458.,  963912.,  971904.,  977376.,  982848.,
      988320.,  996402.,  1001892., 1007382., 1012872., 1021044., 1026552.,
      1032060., 1037568., 957414.,  962940.,  968466.,  973992.,  982056.,
      987600.,  993144.,  998688.,  1006842., 1012404., 1017966., 1023528.,
      1031772., 1037352., 1042932., 1048512., 967278.,  972876.,  978474.,
      984072.,  992208.,  997824.,  1003440., 1009056., 1017282., 1022916.,
      1028550., 1034184., 1042500., 1048152., 1053804., 1059456., 977142.,
      982812.,  988482.,  994152.,  1002360., 1008048., 1013736., 1019424.,
      1027722., 1033428., 1039134., 1044840., 1053228., 1058952., 1064676.,
      1070400.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      489180., 571536., 654096., 572880., 491484., 620835.,  724920.,
      829140., 725760., 622275., 753930., 879816., 1005720., 879816.,
      753930., 622275., 725760., 829140., 724920., 620835.,  491484.,
      572880., 654096., 571536., 489180.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22716., 23016., 23316., 23616., 23916., 25116., 25416., 25716., 26016.,
      26316., 27516., 27816., 28116., 28416., 28716., 29916., 30216., 30516.,
      30816., 31116., 32316., 32616., 32916., 33216., 33516.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      973788.,  978360.,  1137696., 1143072., 1302000., 1308192., 1140300.,
      1145760., 978252.,  982968.,  1235595., 1241670., 1442700., 1449840.,
      1650060., 1658280., 1444275., 1451520., 1238295., 1244550., 1500138.,
      1507860., 1750560., 1759632., 2001000., 2011440., 1750434., 1759632.,
      1499922., 1507860., 1237755., 1244550., 1443540., 1451520., 1649100.,
      1658280., 1441755., 1449840., 1234695., 1241670., 977244.,  982968.,
      1139040., 1145760., 1300464., 1308192., 1136268., 1143072., 972492.,
      978360.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44124., 45432., 44700., 46032., 45276., 46632., 45852., 47232., 46428.,
      47832., 48732., 50232., 49308., 50832., 49884., 51432., 50460., 52032.,
      51036., 52632., 53340., 55032., 53916., 55632., 54492., 56232., 55068.,
      56832., 55644., 57432., 57948., 59832., 58524., 60432., 59100., 61032.,
      59676., 61632., 60252., 62232., 62556., 64632., 63132., 65232., 63708.,
      65832., 64284., 66432., 64860., 67032.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1943004., 1947576., 1952148., 1956720., 2270016., 2275392., 2280768.,
      2286144., 2597808., 2604000., 2610192., 2616384., 2275140., 2280600.,
      2286060., 2291520., 1951788., 1956504., 1961220., 1965936., 2465115.,
      2471190., 2477265., 2483340., 2878260., 2885400., 2892540., 2899680.,
      3291900., 3300120., 3308340., 3316560., 2881305., 2888550., 2895795.,
      2903040., 2470335., 2476590., 2482845., 2489100., 2992554., 3000276.,
      3007998., 3015720., 3492048., 3501120., 3510192., 3519264., 3991560.,
      4002000., 4012440., 4022880., 3491670., 3500868., 3510066., 3519264.,
      2991906., 2999844., 3007782., 3015720., 2468715., 2475510., 2482305.,
      2489100., 2879100., 2887080., 2895060., 2903040., 3289020., 3298200.,
      3307380., 3316560., 2875425., 2883510., 2891595., 2899680., 2462415.,
      2469390., 2476365., 2483340., 1948764., 1954488., 1960212., 1965936.,
      2271360., 2278080., 2284800., 2291520., 2593200., 2600928., 2608656.,
      2616384., 2265732., 2272536., 2279340., 2286144., 1939116., 1944984.,
      1950852., 1956720.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86940.,  88248.,  89556.,  90864.,  88068.,  89400.,  90732.,  92064.,
      89196.,  90552.,  91908.,  93264.,  90324.,  91704.,  93084.,  94464.,
      91452.,  92856.,  94260.,  95664.,  95964.,  97464.,  98964.,  100464.,
      97092.,  98616.,  100140., 101664., 98220.,  99768.,  101316., 102864.,
      99348.,  100920., 102492., 104064., 100476., 102072., 103668., 105264.,
      104988., 106680., 108372., 110064., 106116., 107832., 109548., 111264.,
      107244., 108984., 110724., 112464., 108372., 110136., 111900., 113664.,
      109500., 111288., 113076., 114864., 114012., 115896., 117780., 119664.,
      115140., 117048., 118956., 120864., 116268., 118200., 120132., 122064.,
      117396., 119352., 121308., 123264., 118524., 120504., 122484., 124464.,
      123036., 125112., 127188., 129264., 124164., 126264., 128364., 130464.,
      125292., 127416., 129540., 131664., 126420., 128568., 130716., 132864.,
      127548., 129720., 131892., 134064.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1935912., 1956720., 2261868., 2286144., 2588640., 2616384., 2267244.,
      2291520., 1945128., 1965936., 2457330., 2483340., 2869335., 2899680.,
      3281880., 3316560., 2872695., 2903040., 2463090., 2489100., 2984508.,
      3015720., 3482850., 3519264., 3981264., 4022880., 3482850., 3519264.,
      2984508., 3015720., 2463090., 2489100., 2872695., 2903040., 3281880.,
      3316560., 2869335., 2899680., 2457330., 2483340., 1945128., 1965936.,
      2267244., 2291520., 2588640., 2616384., 2261868., 2286144., 1935912.,
      1956720.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      87672.,  90864.,  88824.,  92064.,  89976.,  93264.,  91128.,  94464.,
      92280.,  95664.,  96888.,  100464., 98040.,  101664., 99192.,  102864.,
      100344., 104064., 101496., 105264., 106104., 110064., 107256., 111264.,
      108408., 112464., 109560., 113664., 110712., 114864., 115320., 119664.,
      116472., 120864., 117624., 122064., 118776., 123264., 119928., 124464.,
      124536., 129264., 125688., 130464., 126840., 131664., 127992., 132864.,
      129144., 134064.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3862752., 3871824., 3904296., 3913440., 4513068., 4523736., 4561536.,
      4572288., 5164992., 5177280., 5220384., 5232768., 4523652., 4534488.,
      4572120., 4583040., 3880896., 3890256., 3922440., 3931872., 4902600.,
      4914660., 4954530., 4966680., 5724495., 5738670., 5785080., 5799360.,
      6547440., 6563760., 6616680., 6633120., 5731005., 5745390., 5791590.,
      5806080., 4913760., 4926180., 4965690., 4978200., 5953680., 5969016.,
      6015996., 6031440., 6947682., 6965700., 7020384., 7038528., 7941792.,
      7962528., 8024880., 8045760., 6947430., 6965700., 7020132., 7038528.,
      5953248., 5969016., 6015564., 6031440., 4912680., 4926180., 4964610.,
      4978200., 5729535., 5745390., 5790120., 5806080., 6545520., 6563760.,
      6614760., 6633120., 5722605., 5738670., 5783190., 5799360., 4900800.,
      4914660., 4952730., 4966680., 3878880., 3890256., 3920424., 3931872.,
      4521132., 4534488., 4569600., 4583040., 5161920., 5177280., 5217312.,
      5232768., 4510212., 4523736., 4558680., 4572288., 3860160., 3871824.,
      3901704., 3913440.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      172752., 175344., 179112., 181728., 175008., 177648., 181464., 184128.,
      177264., 179952., 183816., 186528., 179520., 182256., 186168., 188928.,
      181776., 184560., 188520., 191328., 190800., 193776., 197928., 200928.,
      193056., 196080., 200280., 203328., 195312., 198384., 202632., 205728.,
      197568., 200688., 204984., 208128., 199824., 202992., 207336., 210528.,
      208848., 212208., 216744., 220128., 211104., 214512., 219096., 222528.,
      213360., 216816., 221448., 224928., 215616., 219120., 223800., 227328.,
      217872., 221424., 226152., 229728., 226896., 230640., 235560., 239328.,
      229152., 232944., 237912., 241728., 231408., 235248., 240264., 244128.,
      233664., 237552., 242616., 246528., 235920., 239856., 244968., 248928.,
      244944., 249072., 254376., 258528., 247200., 251376., 256728., 260928.,
      249456., 253680., 259080., 263328., 251712., 255984., 261432., 265728.,
      253968., 258288., 263784., 268128.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7716432.,  7725504.,  7734576.,  7743648.,  7799448.,  7808592.,
      7817736.,  7826880.,  9015468.,  9026136.,  9036804.,  9047472.,
      9112320.,  9123072.,  9133824.,  9144576.,  10317696., 10329984.,
      10342272., 10354560., 10428384., 10440768., 10453152., 10465536.,
      9036468.,  9047304.,  9058140.,  9068976.,  9133320.,  9144240.,
      9155160.,  9166080.,  7752432.,  7761792.,  7771152.,  7780512.,
      7835448.,  7844880.,  7854312.,  7863744.,  9793140.,  9805200.,
      9817260.,  9829320.,  9896910.,  9909060.,  9921210.,  9933360.,
      11434815., 11448990., 11463165., 11477340., 11555880., 11570160.,
      11584440., 11598720., 13078560., 13094880., 13111200., 13127520.,
      13216920., 13233360., 13249800., 13266240., 11447625., 11462010.,
      11476395., 11490780., 11568690., 11583180., 11597670., 11612160.,
      9815100.,  9827520.,  9839940.,  9852360.,  9918870.,  9931380.,
      9943890.,  9956400.,  11892024., 11907360., 11922696., 11938032.,
      12016548., 12031992., 12047436., 12062880., 13877346., 13895364.,
      13913382., 13931400., 14022624., 14040768., 14058912., 14077056.,
      15862848., 15883584., 15904320., 15925056., 16028880., 16049760.,
      16070640., 16091520., 13876590., 13894860., 13913130., 13931400.,
      14021868., 14040264., 14058660., 14077056., 11890728., 11906496.,
      11922264., 11938032., 12015252., 12031128., 12047004., 12062880.,
      9811860.,  9825360.,  9838860.,  9852360.,  9915630.,  9929220.,
      9942810.,  9956400.,  11443215., 11459070., 11474925., 11490780.,
      11564280., 11580240., 11596200., 11612160., 13072800., 13091040.,
      13109280., 13127520., 13211160., 13229520., 13247880., 13266240.,
      11429145., 11445210., 11461275., 11477340., 11550210., 11566380.,
      11582550., 11598720., 9787740.,  9801600.,  9815460.,  9829320.,
      9891510.,  9905460.,  9919410.,  9933360.,  7746384.,  7757760.,
      7769136.,  7780512.,  7829400.,  7840848.,  7852296.,  7863744.,
      9028908.,  9042264.,  9055620.,  9068976.,  9125760.,  9139200.,
      9152640.,  9166080.,  10308480., 10323840., 10339200., 10354560.,
      10419168., 10434624., 10450080., 10465536., 9006900.,  9020424.,
      9033948.,  9047472.,  9103752.,  9117360.,  9130968.,  9144576.,
      7708656.,  7720320.,  7731984.,  7743648.,  7791672.,  7803408.,
      7815144.,  7826880.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      342912., 345504., 348096., 350688., 355608., 358224., 360840., 363456.,
      347376., 350016., 352656., 355296., 360264., 362928., 365592., 368256.,
      351840., 354528., 357216., 359904., 364920., 367632., 370344., 373056.,
      356304., 359040., 361776., 364512., 369576., 372336., 375096., 377856.,
      360768., 363552., 366336., 369120., 374232., 377040., 379848., 382656.,
      378624., 381600., 384576., 387552., 392856., 395856., 398856., 401856.,
      383088., 386112., 389136., 392160., 397512., 400560., 403608., 406656.,
      387552., 390624., 393696., 396768., 402168., 405264., 408360., 411456.,
      392016., 395136., 398256., 401376., 406824., 409968., 413112., 416256.,
      396480., 399648., 402816., 405984., 411480., 414672., 417864., 421056.,
      414336., 417696., 421056., 424416., 430104., 433488., 436872., 440256.,
      418800., 422208., 425616., 429024., 434760., 438192., 441624., 445056.,
      423264., 426720., 430176., 433632., 439416., 442896., 446376., 449856.,
      427728., 431232., 434736., 438240., 444072., 447600., 451128., 454656.,
      432192., 435744., 439296., 442848., 448728., 452304., 455880., 459456.,
      450048., 453792., 457536., 461280., 467352., 471120., 474888., 478656.,
      454512., 458304., 462096., 465888., 472008., 475824., 479640., 483456.,
      458976., 462816., 466656., 470496., 476664., 480528., 484392., 488256.,
      463440., 467328., 471216., 475104., 481320., 485232., 489144., 493056.,
      467904., 471840., 475776., 479712., 485976., 489936., 493896., 497856.,
      485760., 489888., 494016., 498144., 504600., 508752., 512904., 517056.,
      490224., 494400., 498576., 502752., 509256., 513456., 517656., 521856.,
      494688., 498912., 503136., 507360., 513912., 518160., 522408., 526656.,
      499152., 503424., 507696., 511968., 518568., 522864., 527160., 531456.,
      503616., 507936., 512256., 516576., 523224., 527568., 531912., 536256.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7702248.,  7743648.,  7785192.,  7826880.,  8999172.,  9047472.,
      9095940.,  9144576.,  10299360., 10354560., 10409952., 10465536.,
      9020676.,  9068976.,  9117444.,  9166080.,  7739112.,  7780512.,
      7822056.,  7863744.,  9777570.,  9829320.,  9881250.,  9933360.,
      11416965., 11477340., 11537925., 11598720., 13058520., 13127520.,
      13196760., 13266240., 11430405., 11490780., 11551365., 11612160.,
      9800610.,  9852360.,  9904290.,  9956400.,  11875932., 11938032.,
      12000348., 12062880., 13858950., 13931400., 14004102., 14077056.,
      15842256., 15925056., 16008144., 16091520., 13858950., 13931400.,
      14004102., 14077056., 11875932., 11938032., 12000348., 12062880.,
      9800610.,  9852360.,  9904290.,  9956400.,  11430405., 11490780.,
      11551365., 11612160., 13058520., 13127520., 13196760., 13266240.,
      11416965., 11477340., 11537925., 11598720., 9777570.,  9829320.,
      9881250.,  9933360.,  7739112.,  7780512.,  7822056.,  7863744.,
      9020676.,  9068976.,  9117444.,  9166080.,  10299360., 10354560.,
      10409952., 10465536., 8999172.,  9047472.,  9095940.,  9144576.,
      7702248.,  7743648.,  7785192.,  7826880.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344376., 350688., 357048., 363456., 348888., 355296., 361752., 368256.,
      353400., 359904., 366456., 373056., 357912., 364512., 371160., 377856.,
      362424., 369120., 375864., 382656., 380472., 387552., 394680., 401856.,
      384984., 392160., 399384., 406656., 389496., 396768., 404088., 411456.,
      394008., 401376., 408792., 416256., 398520., 405984., 413496., 421056.,
      416568., 424416., 432312., 440256., 421080., 429024., 437016., 445056.,
      425592., 433632., 441720., 449856., 430104., 438240., 446424., 454656.,
      434616., 442848., 451128., 459456., 452664., 461280., 469944., 478656.,
      457176., 465888., 474648., 483456., 461688., 470496., 479352., 488256.,
      466200., 475104., 484056., 493056., 470712., 479712., 488760., 497856.,
      488760., 498144., 507576., 517056., 493272., 502752., 512280., 521856.,
      497784., 507360., 516984., 526656., 502296., 511968., 521688., 531456.,
      506808., 516576., 526392., 536256.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3940152., 3958224., 3992160., 4010304., 4044456., 4062672.,  4097040.,
      4115328., 4551428., 4572680., 4612104., 4633440., 4673116.,  4694536.,
      4734464., 4755968., 5148704., 5173184., 5218048., 5242624.,  5287776.,
      5312448., 5357888., 5382656., 4450740., 4472328., 4511416.,  4533088.,
      4572428., 4594184., 4633776., 4655616., 3767544., 3786192.,  3819552.,
      3838272., 3871848., 3890640., 3924432., 3943296., 5578086.,  5599044.,
      5641560., 5662608., 5705394., 5726532., 5769588., 5790816.,  6462645.,
      6487306., 6536698., 6561464., 6611171., 6636042., 6686064.,  6711040.,
      7333032., 7361456., 7417664., 7446208., 7502776., 7531440.,  7588368.,
      7617152., 6360081., 6385162., 6434134., 6459320., 6508607.,  6533898.,
      6583500., 6608896., 5402262., 5423940., 5465736., 5487504.,  5529570.,
      5551428., 5593764., 5615712., 7359828., 7384248., 7434768.,  7459296.,
      7510140., 7534776., 7585944., 7610688., 8536262., 8565004.,  8623692.,
      8652560., 8711626., 8740620., 8800064., 8829184., 9696816.,  9729952.,
      9796736., 9830016., 9897232., 9930656., 9998304., 10031872., 8421070.,
      8450316., 8508500., 8537872., 8596434., 8625932., 8684872.,  8714496.,
      7162356., 7187640., 7237296., 7262688., 7312668., 7338168.,  7388472.,
      7414080., 5673510., 5694276., 5736984., 5757840., 5800818.,  5821764.,
      5865012., 5886048., 6575765., 6600202., 6649818., 6674360.,  6724291.,
      6748938., 6799184., 6823936., 7464360., 7492528., 7548992.,  7577280.,
      7634104., 7662512., 7719696., 7748224., 6476785., 6501642.,  6550838.,
      6575800., 6625311., 6650378., 6700204., 6725376., 5503830.,  5525316.,
      5567304., 5588880., 5631138., 5652804., 5695332., 5717088.,  4310328.,
      4326864., 4362336., 4378944., 4414632., 4431312., 4467216.,  4483968.,
      4997636., 5017096., 5058312., 5077856., 5119324., 5138952.,  5180672.,
      5200384., 5675040., 5697472., 5744384., 5766912., 5814112.,  5836736.,
      5884224., 5906944., 4925620., 4945416., 4986296., 5006176.,  5047308.,
      5067272., 5108656., 5128704., 4186872., 4203984., 4238880.,  4256064.,
      4291176., 4308432., 4343760., 4361088.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      683592.,  688752.,  696192.,  701376.,  708888.,  714096.,  721680.,
      726912.,  692520.,  697776.,  705312.,  710592.,  718200.,  723504.,
      731184.,  736512.,  701448.,  706800.,  714432.,  719808.,  727512.,
      732912.,  740688.,  746112.,  710376.,  715824.,  723552.,  729024.,
      736824.,  742320.,  750192.,  755712.,  719304.,  724848.,  732672.,
      738240.,  746136.,  751728.,  759696.,  765312.,  755016.,  760944.,
      769152.,  775104.,  783384.,  789360.,  797712.,  803712.,  763944.,
      769968.,  778272.,  784320.,  792696.,  798768.,  807216.,  813312.,
      772872.,  778992.,  787392.,  793536.,  802008.,  808176.,  816720.,
      822912.,  781800.,  788016.,  796512.,  802752.,  811320.,  817584.,
      826224.,  832512.,  790728.,  797040.,  805632.,  811968.,  820632.,
      826992.,  835728.,  842112.,  826440.,  833136.,  842112.,  848832.,
      857880.,  864624.,  873744.,  880512.,  835368.,  842160.,  851232.,
      858048.,  867192.,  874032.,  883248.,  890112.,  844296.,  851184.,
      860352.,  867264.,  876504.,  883440.,  892752.,  899712.,  853224.,
      860208.,  869472.,  876480.,  885816.,  892848.,  902256.,  909312.,
      862152.,  869232.,  878592.,  885696.,  895128.,  902256.,  911760.,
      918912.,  897864.,  905328.,  915072.,  922560.,  932376.,  939888.,
      949776.,  957312.,  906792.,  914352.,  924192.,  931776.,  941688.,
      949296.,  959280.,  966912.,  915720.,  923376.,  933312.,  940992.,
      951000.,  958704.,  968784.,  976512.,  924648.,  932400.,  942432.,
      950208.,  960312.,  968112.,  978288.,  986112.,  933576.,  941424.,
      951552.,  959424.,  969624.,  977520.,  987792.,  995712.,  969288.,
      977520.,  988032.,  996288.,  1006872., 1015152., 1025808., 1034112.,
      978216.,  986544.,  997152.,  1005504., 1016184., 1024560., 1035312.,
      1043712., 987144.,  995568.,  1006272., 1014720., 1025496., 1033968.,
      1044816., 1053312., 996072.,  1004592., 1015392., 1023936., 1034808.,
      1043376., 1054320., 1062912., 1005000., 1013616., 1024512., 1033152.,
      1044120., 1052784., 1063824., 1072512.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4777944., 4796016., 4814088., 4832160., 4869600., 4887744., 4905888.,
      4924032., 4961832., 4980048., 4998264., 5016480., 5054640., 5072928.,
      5091216., 5109504., 5454596., 5475848., 5497100., 5518352., 5561528.,
      5582864., 5604200., 5625536., 5669132., 5690552., 5711972., 5733392.,
      5777408., 5798912., 5820416., 5841920., 6095008., 6119488., 6143968.,
      6168448., 6217216., 6241792., 6266368., 6290944., 6340192., 6364864.,
      6389536., 6414208., 6463936., 6488704., 6513472., 6538240., 5195540.,
      5217128., 5238716., 5260304., 5302472., 5324144., 5345816., 5367488.,
      5410076., 5431832., 5453588., 5475344., 5518352., 5540192., 5562032.,
      5583872., 4333848., 4352496., 4371144., 4389792., 4425504., 4444224.,
      4462944., 4481664., 4517736., 4536528., 4555320., 4574112., 4610544.,
      4629408., 4648272., 4667136., 5820654., 5841612., 5862570., 5883528.,
      5929080., 5950128., 5971176., 5992224., 6038226., 6059364., 6080502.,
      6101640., 6148092., 6169320., 6190548., 6211776., 6657301., 6681962.,
      6706623., 6731284., 6783798., 6808564., 6833330., 6858096., 6911135.,
      6936006., 6960877., 6985748., 7039312., 7064288., 7089264., 7114240.,
      7453256., 7481680., 7510104., 7538528., 7597824., 7626368., 7654912.,
      7683456., 7743352., 7772016., 7800680., 7829344., 7889840., 7918624.,
      7947408., 7976192., 6365737., 6390818., 6415899., 6440980., 6492234.,
      6517420., 6542606., 6567792., 6619571., 6644862., 6670153., 6695444.,
      6747748., 6773144., 6798540., 6823936., 5320830., 5342508., 5364186.,
      5385864., 5429256., 5451024., 5472792., 5494560., 5538402., 5560260.,
      5582118., 5603976., 5648268., 5670216., 5692164., 5714112., 6953796.,
      6978216., 7002636., 7027056., 7078992., 7103520., 7128048., 7152576.,
      7205052., 7229688., 7254324., 7278960., 7331976., 7356720., 7381464.,
      7406208., 7954758., 7983500., 8012242., 8040984., 8100820., 8129688.,
      8158556., 8187424., 8247890., 8276884., 8305878., 8334872., 8395968.,
      8425088., 8454208., 8483328., 8907504., 8940640., 8973776., 9006912.,
      9074432., 9107712., 9140992., 9174272., 9242512., 9275936., 9309360.,
      9342784., 9411744., 9445312., 9478880., 9512448., 7609182., 7638428.,
      7667674., 7696920., 7755244., 7784616., 7813988., 7843360., 7902314.,
      7931812., 7961310., 7990808., 8050392., 8080016., 8109640., 8139264.,
      6361380., 6386664., 6411948., 6437232., 6486576., 6511968., 6537360.,
      6562752., 6612636., 6638136., 6663636., 6689136., 6739560., 6765168.,
      6790776., 6816384., 4994862., 5015628., 5036394., 5057160., 5100216.,
      5121072., 5141928., 5162784., 5206290., 5227236., 5248182., 5269128.,
      5313084., 5334120., 5355156., 5376192., 5690293., 5714730., 5739167.,
      5763604., 5813206., 5837748., 5862290., 5886832., 5936959., 5961606.,
      5986253., 6010900., 6061552., 6086304., 6111056., 6135808., 6344008.,
      6372176., 6400344., 6428512., 6484480., 6512768., 6541056., 6569344.,
      6625912., 6654320., 6682728., 6711136., 6768304., 6796832., 6825360.,
      6853888., 5391561., 5416418., 5441275., 5466132., 5514474., 5539436.,
      5564398., 5589360., 5638227., 5663294., 5688361., 5713428., 5762820.,
      5787992., 5813164., 5838336., 4482750., 4504236., 4525722., 4547208.,
      4588104., 4609680., 4631256., 4652832., 4694178., 4715844., 4737510.,
      4759176., 4800972., 4822728., 4844484., 4866240., 3781080., 3797616.,
      3814152., 3830688., 3866592., 3883200., 3899808., 3916416., 3952680.,
      3969360., 3986040., 4002720., 4039344., 4056096., 4072848., 4089600.,
      4305924., 4325384., 4344844., 4364304., 4405688., 4425232., 4444776.,
      4464320., 4506124., 4525752., 4545380., 4565008., 4607232., 4626944.,
      4646656., 4666368., 4798624., 4821056., 4843488., 4865920., 4912640.,
      4935168., 4957696., 4980224., 5027424., 5050048., 5072672., 5095296.,
      5142976., 5165696., 5188416., 5211136., 4075540., 4095336., 4115132.,
      4134928., 4175304., 4195184., 4215064., 4234944., 4275740., 4295704.,
      4315668., 4335632., 4376848., 4396896., 4416944., 4436992., 3386136.,
      3403248., 3420360., 3437472., 3471648., 3488832., 3506016., 3523200.,
      3557736., 3574992., 3592248., 3609504., 3644400., 3661728., 3679056.,
      3696384.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1362024., 1367184., 1372344., 1377504., 1387200., 1392384., 1397568.,
      1402752., 1412568., 1417776., 1422984., 1428192., 1438128., 1443360.,
      1448592., 1453824., 1379784., 1385040., 1390296., 1395552., 1405344.,
      1410624., 1415904., 1421184., 1431096., 1436400., 1441704., 1447008.,
      1457040., 1462368., 1467696., 1473024., 1397544., 1402896., 1408248.,
      1413600., 1423488., 1428864., 1434240., 1439616., 1449624., 1455024.,
      1460424., 1465824., 1475952., 1481376., 1486800., 1492224., 1415304.,
      1420752., 1426200., 1431648., 1441632., 1447104., 1452576., 1458048.,
      1468152., 1473648., 1479144., 1484640., 1494864., 1500384., 1505904.,
      1511424., 1433064., 1438608., 1444152., 1449696., 1459776., 1465344.,
      1470912., 1476480., 1486680., 1492272., 1497864., 1503456., 1513776.,
      1519392., 1525008., 1530624., 1504104., 1510032., 1515960., 1521888.,
      1532352., 1538304., 1544256., 1550208., 1560792., 1566768., 1572744.,
      1578720., 1589424., 1595424., 1601424., 1607424., 1521864., 1527888.,
      1533912., 1539936., 1550496., 1556544., 1562592., 1568640., 1579320.,
      1585392., 1591464., 1597536., 1608336., 1614432., 1620528., 1626624.,
      1539624., 1545744., 1551864., 1557984., 1568640., 1574784., 1580928.,
      1587072., 1597848., 1604016., 1610184., 1616352., 1627248., 1633440.,
      1639632., 1645824., 1557384., 1563600., 1569816., 1576032., 1586784.,
      1593024., 1599264., 1605504., 1616376., 1622640., 1628904., 1635168.,
      1646160., 1652448., 1658736., 1665024., 1575144., 1581456., 1587768.,
      1594080., 1604928., 1611264., 1617600., 1623936., 1634904., 1641264.,
      1647624., 1653984., 1665072., 1671456., 1677840., 1684224., 1646184.,
      1652880., 1659576., 1666272., 1677504., 1684224., 1690944., 1697664.,
      1709016., 1715760., 1722504., 1729248., 1740720., 1747488., 1754256.,
      1761024., 1663944., 1670736., 1677528., 1684320., 1695648., 1702464.,
      1709280., 1716096., 1727544., 1734384., 1741224., 1748064., 1759632.,
      1766496., 1773360., 1780224., 1681704., 1688592., 1695480., 1702368.,
      1713792., 1720704., 1727616., 1734528., 1746072., 1753008., 1759944.,
      1766880., 1778544., 1785504., 1792464., 1799424., 1699464., 1706448.,
      1713432., 1720416., 1731936., 1738944., 1745952., 1752960., 1764600.,
      1771632., 1778664., 1785696., 1797456., 1804512., 1811568., 1818624.,
      1717224., 1724304., 1731384., 1738464., 1750080., 1757184., 1764288.,
      1771392., 1783128., 1790256., 1797384., 1804512., 1816368., 1823520.,
      1830672., 1837824., 1788264., 1795728., 1803192., 1810656., 1822656.,
      1830144., 1837632., 1845120., 1857240., 1864752., 1872264., 1879776.,
      1892016., 1899552., 1907088., 1914624., 1806024., 1813584., 1821144.,
      1828704., 1840800., 1848384., 1855968., 1863552., 1875768., 1883376.,
      1890984., 1898592., 1910928., 1918560., 1926192., 1933824., 1823784.,
      1831440., 1839096., 1846752., 1858944., 1866624., 1874304., 1881984.,
      1894296., 1902000., 1909704., 1917408., 1929840., 1937568., 1945296.,
      1953024., 1841544., 1849296., 1857048., 1864800., 1877088., 1884864.,
      1892640., 1900416., 1912824., 1920624., 1928424., 1936224., 1948752.,
      1956576., 1964400., 1972224., 1859304., 1867152., 1875000., 1882848.,
      1895232., 1903104., 1910976., 1918848., 1931352., 1939248., 1947144.,
      1955040., 1967664., 1975584., 1983504., 1991424., 1930344., 1938576.,
      1946808., 1955040., 1967808., 1976064., 1984320., 1992576., 2005464.,
      2013744., 2022024., 2030304., 2043312., 2051616., 2059920., 2068224.,
      1948104., 1956432., 1964760., 1973088., 1985952., 1994304., 2002656.,
      2011008., 2023992., 2032368., 2040744., 2049120., 2062224., 2070624.,
      2079024., 2087424., 1965864., 1974288., 1982712., 1991136., 2004096.,
      2012544., 2020992., 2029440., 2042520., 2050992., 2059464., 2067936.,
      2081136., 2089632., 2098128., 2106624., 1983624., 1992144., 2000664.,
      2009184., 2022240., 2030784., 2039328., 2047872., 2061048., 2069616.,
      2078184., 2086752., 2100048., 2108640., 2117232., 2125824., 2001384.,
      2010000., 2018616., 2027232., 2040384., 2049024., 2057664., 2066304.,
      2079576., 2088240., 2096904., 2105568., 2118960., 2127648., 2136336.,
      2145024.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      313950., 393000., 472245., 393900., 315390., 381492., 477270.,
      573174., 477810., 382356., 449610., 562170., 674751., 562170.,
      449610., 382356., 477810., 573174., 477270., 381492., 315390.,
      393900., 472245., 393000., 313950.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11637., 11808., 11979., 12150., 12321., 12663., 12834., 13005., 13176.,
      13347., 13689., 13860., 14031., 14202., 14373., 14715., 14886., 15057.,
      15228., 15399., 15741., 15912., 16083., 16254., 16425.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      624510.,  627900.,  781725.,  786000.,  939315.,  944490.,  783450.,
      787800.,  627270.,  630780.,  758700.,  762984.,  949140.,  954540.,
      1139814., 1146348., 950130.,  955620.,  760284.,  764712.,  893970.,
      899220.,  1117725., 1124340., 1341501., 1349502., 1117620., 1124340.,
      893802.,  899220.,  759996.,  764712.,  949680.,  955620.,  1139166.,
      1146348., 948510.,  954540.,  758124.,  762984.,  626670.,  630780.,
      782625.,  787800.,  938235.,  944490.,  780750.,  786000.,  623670.,
      627900.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22383., 23274., 22707., 23616., 23031., 23958., 23355., 24300., 23679.,
      24642., 24327., 25326., 24651., 25668., 24975., 26010., 25299., 26352.,
      25623., 26694., 26271., 27378., 26595., 27720., 26919., 28062., 27243.,
      28404., 27567., 28746., 28215., 29430., 28539., 29772., 28863., 30114.,
      29187., 30456., 29511., 30798., 30159., 31482., 30483., 31824., 30807.,
      32166., 31131., 32508., 31455., 32850.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1245630., 1249020., 1252410., 1255800., 1559175., 1563450., 1567725.,
      1572000., 1873455., 1878630., 1883805., 1888980., 1562550., 1566900.,
      1571250., 1575600., 1251030., 1254540., 1258050., 1261560., 1513116.,
      1517400., 1521684., 1525968., 1892880., 1898280., 1903680., 1909080.,
      2273094., 2279628., 2286162., 2292696., 1894770., 1900260., 1905750.,
      1911240., 1516140., 1520568., 1524996., 1529424., 1782690., 1787940.,
      1793190., 1798440., 2228835., 2235450., 2242065., 2248680., 2675001.,
      2683002., 2691003., 2699004., 2228520., 2235240., 2241960., 2248680.,
      1782186., 1787604., 1793022., 1798440., 1515276., 1519992., 1524708.,
      1529424., 1893420., 1899360., 1905300., 1911240., 2271150., 2278332.,
      2285514., 2292696., 1890990., 1897020., 1903050., 1909080., 1511388.,
      1516248., 1521108., 1525968., 1249230., 1253340., 1257450., 1261560.,
      1560075., 1565250., 1570425., 1575600., 1870215., 1876470., 1882725.,
      1888980., 1556250., 1561500., 1566750., 1572000., 1243110., 1247340.,
      1251570., 1255800.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      43875., 44766., 45657., 46548., 44505., 45414., 46323., 47232., 45135.,
      46062., 46989., 47916., 45765., 46710., 47655., 48600., 46395., 47358.,
      48321., 49284., 47655., 48654., 49653., 50652., 48285., 49302., 50319.,
      51336., 48915., 49950., 50985., 52020., 49545., 50598., 51651., 52704.,
      50175., 51246., 52317., 53388., 51435., 52542., 53649., 54756., 52065.,
      53190., 54315., 55440., 52695., 53838., 54981., 56124., 53325., 54486.,
      55647., 56808., 53955., 55134., 56313., 57492., 55215., 56430., 57645.,
      58860., 55845., 57078., 58311., 59544., 56475., 57726., 58977., 60228.,
      57105., 58374., 59643., 60912., 57735., 59022., 60309., 61596., 58995.,
      60318., 61641., 62964., 59625., 60966., 62307., 63648., 60255., 61614.,
      62973., 64332., 60885., 62262., 63639., 65016., 61515., 62910., 64305.,
      65700.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1240620., 1255800., 1553025., 1572000., 1866210., 1888980., 1556625.,
      1575600., 1246380., 1261560., 1507752., 1525968., 1886310., 1909080.,
      2265372., 2292696., 1888470., 1911240., 1511208., 1529424., 1777188.,
      1798440., 2222115., 2248680., 2667126., 2699004., 2222115., 2248680.,
      1777188., 1798440., 1511208., 1529424., 1888470., 1911240., 2265372.,
      2292696., 1886310., 1909080., 1507752., 1525968., 1246380., 1261560.,
      1556625., 1575600., 1866210., 1888980., 1553025., 1572000., 1240620.,
      1255800.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44442., 46548., 45090., 47232., 45738., 47916., 46386., 48600., 47034.,
      49284., 48330., 50652., 48978., 51336., 49626., 52020., 50274., 52704.,
      50922., 53388., 52218., 54756., 52866., 55440., 53514., 56124., 54162.,
      56808., 54810., 57492., 56106., 58860., 56754., 59544., 57402., 60228.,
      58050., 60912., 58698., 61596., 59994., 62964., 60642., 63648., 61290.,
      64332., 61938., 65016., 62586., 65700.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2474520., 2481240., 2504820., 2511600., 3097575., 3106050., 3135450.,
      3144000., 3722160., 3732420., 3767610., 3777960., 3104625., 3113250.,
      3142500., 3151200., 2485800., 2492760., 2516100., 2523120., 3007008.,
      3015504., 3043368., 3051936., 3761910., 3772620., 3807360., 3818160.,
      4517784., 4530744., 4572324., 4585392., 3766050., 3776940., 3811500.,
      3822480., 3013632., 3022416., 3049992., 3058848., 3543960., 3554376.,
      3586380., 3596880., 4431105., 4444230., 4484130., 4497360., 5318376.,
      5334252., 5382006., 5398008., 4430895., 4444230., 4483920., 4497360.,
      3543624., 3554376., 3586044., 3596880., 3013056., 3022416., 3049416.,
      3058848., 3765150., 3776940., 3810600., 3822480., 4516488., 4530744.,
      4571028., 4585392., 3760650., 3772620., 3806100., 3818160., 3005856.,
      3015504., 3042216., 3051936., 2484600., 2492760., 2514900., 2523120.,
      3102975., 3113250., 3140850., 3151200., 3720000., 3732420., 3765450.,
      3777960., 3095625., 3106050., 3133500., 3144000., 2472840., 2481240.,
      2503140., 2511600.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      87120.,  88884.,  91314.,  93096.,  88380.,  90180.,  92646.,  94464.,
      89640.,  91476.,  93978.,  95832.,  90900.,  92772.,  95310.,  97200.,
      92160.,  94068.,  96642.,  98568.,  94680.,  96660.,  99306.,  101304.,
      95940.,  97956.,  100638., 102672., 97200.,  99252.,  101970., 104040.,
      98460.,  100548., 103302., 105408., 99720.,  101844., 104634., 106776.,
      102240., 104436., 107298., 109512., 103500., 105732., 108630., 110880.,
      104760., 107028., 109962., 112248., 106020., 108324., 111294., 113616.,
      107280., 109620., 112626., 114984., 109800., 112212., 115290., 117720.,
      111060., 113508., 116622., 119088., 112320., 114804., 117954., 120456.,
      113580., 116100., 119286., 121824., 114840., 117396., 120618., 123192.,
      117360., 119988., 123282., 125928., 118620., 121284., 124614., 127296.,
      119880., 122580., 125946., 128664., 121140., 123876., 127278., 130032.,
      122400., 125172., 128610., 131400.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4942320.,  4949040.,  4955760.,  4962480.,  5002860.,  5009640.,
      5016420.,  5023200.,  6186675.,  6195150.,  6203625.,  6212100.,
      6262350.,  6270900.,  6279450.,  6288000.,  7434060.,  7444320.,
      7454580.,  7464840.,  7524870.,  7535220.,  7545570.,  7555920.,
      6200625.,  6209250.,  6217875.,  6226500.,  6276300.,  6285000.,
      6293700.,  6302400.,  4964640.,  4971600.,  4978560.,  4985520.,
      5025180.,  5032200.,  5039220.,  5046240.,  6005520.,  6014016.,
      6022512.,  6031008.,  6078168.,  6086736.,  6095304.,  6103872.,
      7513110.,  7523820.,  7534530.,  7545240.,  7603920.,  7614720.,
      7625520.,  7636320.,  9022608.,  9035568.,  9048528.,  9061488.,
      9131580.,  9144648.,  9157716.,  9170784.,  7521210.,  7532100.,
      7542990.,  7553880.,  7612020.,  7623000.,  7633980.,  7644960.,
      6018480.,  6027264.,  6036048.,  6044832.,  6091128.,  6099984.,
      6108840.,  6117696.,  7077504.,  7087920.,  7098336.,  7108752.,
      7162260.,  7172760.,  7183260.,  7193760.,  8849085.,  8862210.,
      8875335.,  8888460.,  8955030.,  8968260.,  8981490.,  8994720.,
      10620876., 10636752., 10652628., 10668504., 10748010., 10764012.,
      10780014., 10796016., 8848455.,  8861790.,  8875125.,  8888460.,
      8954400.,  8967840.,  8981280.,  8994720.,  7076496.,  7087248.,
      7098000.,  7108752.,  7161252.,  7172088.,  7182924.,  7193760.,
      6016752.,  6026112.,  6035472.,  6044832.,  6089400.,  6098832.,
      6108264.,  6117696.,  7518510.,  7530300.,  7542090.,  7553880.,
      7609320.,  7621200.,  7633080.,  7644960.,  9018720.,  9032976.,
      9047232.,  9061488.,  9127692.,  9142056.,  9156420.,  9170784.,
      7509330.,  7521300.,  7533270.,  7545240.,  7600140.,  7612200.,
      7624260.,  7636320.,  6002064.,  6011712.,  6021360.,  6031008.,
      6074712.,  6084432.,  6094152.,  6103872.,  4961040.,  4969200.,
      4977360.,  4985520.,  5021580.,  5029800.,  5038020.,  5046240.,
      6195675.,  6205950.,  6216225.,  6226500.,  6271350.,  6281700.,
      6292050.,  6302400.,  7427580.,  7440000.,  7452420.,  7464840.,
      7518390.,  7530900.,  7543410.,  7555920.,  6180825.,  6191250.,
      6201675.,  6212100.,  6256500.,  6267000.,  6277500.,  6288000.,
      4937280.,  4945680.,  4954080.,  4962480.,  4997820.,  5006280.,
      5014740.,  5023200.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      172476., 174240., 176004., 177768., 180846., 182628., 184410., 186192.,
      174960., 176760., 178560., 180360., 183474., 185292., 187110., 188928.,
      177444., 179280., 181116., 182952., 186102., 187956., 189810., 191664.,
      179928., 181800., 183672., 185544., 188730., 190620., 192510., 194400.,
      182412., 184320., 186228., 188136., 191358., 193284., 195210., 197136.,
      187380., 189360., 191340., 193320., 196614., 198612., 200610., 202608.,
      189864., 191880., 193896., 195912., 199242., 201276., 203310., 205344.,
      192348., 194400., 196452., 198504., 201870., 203940., 206010., 208080.,
      194832., 196920., 199008., 201096., 204498., 206604., 208710., 210816.,
      197316., 199440., 201564., 203688., 207126., 209268., 211410., 213552.,
      202284., 204480., 206676., 208872., 212382., 214596., 216810., 219024.,
      204768., 207000., 209232., 211464., 215010., 217260., 219510., 221760.,
      207252., 209520., 211788., 214056., 217638., 219924., 222210., 224496.,
      209736., 212040., 214344., 216648., 220266., 222588., 224910., 227232.,
      212220., 214560., 216900., 219240., 222894., 225252., 227610., 229968.,
      217188., 219600., 222012., 224424., 228150., 230580., 233010., 235440.,
      219672., 222120., 224568., 227016., 230778., 233244., 235710., 238176.,
      222156., 224640., 227124., 229608., 233406., 235908., 238410., 240912.,
      224640., 227160., 229680., 232200., 236034., 238572., 241110., 243648.,
      227124., 229680., 232236., 234792., 238662., 241236., 243810., 246384.,
      232092., 234720., 237348., 239976., 243918., 246564., 249210., 251856.,
      234576., 237240., 239904., 242568., 246546., 249228., 251910., 254592.,
      237060., 239760., 242460., 245160., 249174., 251892., 254610., 257328.,
      239544., 242280., 245016., 247752., 251802., 254556., 257310., 260064.,
      242028., 244800., 247572., 250344., 254430., 257220., 260010., 262800.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4932300.,  4962480.,  4992780.,  5023200., 6174375., 6212100., 6249975.,
      6288000.,  7419570.,  7464840.,  7510290., 7555920., 6188775., 6226500.,
      6264375.,  6302400.,  4955340.,  4985520., 5015820., 5046240., 5994792.,
      6031008.,  6067368.,  6103872.,  7499970., 7545240., 7590690., 7636320.,
      9007164.,  9061488.,  9116028.,  9170784., 7508610., 7553880., 7599330.,
      7644960.,  6008616.,  6044832.,  6081192., 6117696., 7066500., 7108752.,
      7151172.,  7193760.,  8835645.,  8888460., 8941485., 8994720., 10605126.,
      10668504., 10732134., 10796016., 8835645., 8888460., 8941485., 8994720.,
      7066500.,  7108752.,  7151172.,  7193760., 6008616., 6044832., 6081192.,
      6117696.,  7508610.,  7553880.,  7599330., 7644960., 9007164., 9061488.,
      9116028.,  9170784.,  7499970.,  7545240., 7590690., 7636320., 5994792.,
      6031008.,  6067368.,  6103872.,  4955340., 4985520., 5015820., 5046240.,
      6188775.,  6226500.,  6264375.,  6302400., 7419570., 7464840., 7510290.,
      7555920.,  6174375.,  6212100.,  6249975., 6288000., 4932300., 4962480.,
      4992780.,  5023200.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      173610., 177768., 181962., 186192., 176130., 180360., 184626., 188928.,
      178650., 182952., 187290., 191664., 181170., 185544., 189954., 194400.,
      183690., 188136., 192618., 197136., 188730., 193320., 197946., 202608.,
      191250., 195912., 200610., 205344., 193770., 198504., 203274., 208080.,
      196290., 201096., 205938., 210816., 198810., 203688., 208602., 213552.,
      203850., 208872., 213930., 219024., 206370., 211464., 216594., 221760.,
      208890., 214056., 219258., 224496., 211410., 216648., 221922., 227232.,
      213930., 219240., 224586., 229968., 218970., 224424., 229914., 235440.,
      221490., 227016., 232578., 238176., 224010., 229608., 235242., 240912.,
      226530., 232200., 237906., 243648., 229050., 234792., 240570., 246384.,
      234090., 239976., 245898., 251856., 236610., 242568., 248562., 254592.,
      239130., 245160., 251226., 257328., 241650., 247752., 253890., 260064.,
      244170., 250344., 256554., 262800.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4121940., 4135320., 4164832., 4178272., 4207964., 4221464., 4251336.,
      4264896., 5177187., 5194062., 5231058., 5248008., 5285229., 5302254.,
      5339700., 5356800., 6222230., 6242660., 6287080., 6307600., 6352290.,
      6372900., 6417860., 6438560., 5226679., 5243854., 5281062., 5298312.,
      5335745., 5353070., 5390728., 5408128., 4244340., 4258200., 4288256.,
      4302176., 4332412., 4346392., 4376808., 4390848., 5123128., 5140048.,
      5176032., 5193024., 5229224., 5246288., 5282704., 5299840., 6424626.,
      6445956., 6491012., 6512432., 6557758., 6579268., 6624864., 6646464.,
      7711652., 7737464., 7791520., 7817440., 7871820., 7897848., 7952552.,
      7978688., 6464586., 6486276., 6531484., 6553264., 6598742., 6620612.,
      6666360., 6688320., 5235192., 5252688., 5289120., 5306688., 5343336.,
      5360976., 5397840., 5415552., 6093308., 6114056., 6156224., 6177056.,
      6219476., 6240392., 6283064., 6304064., 7630425., 7656570., 7709326.,
      7735576., 7788647., 7815002., 7868388., 7894848., 9147650., 9179276.,
      9242536., 9274288., 9337926., 9369804., 9433820., 9465824., 7655093.,
      7681658., 7734506., 7761176., 7814339., 7841114., 7894592., 7921472.,
      6185820., 6207240., 6249760., 6271264., 6314036., 6335624., 6378648.,
      6400320., 5212536., 5231184., 5267488., 5286208., 5322728., 5341520.,
      5378256., 5397120., 6536514., 6560004., 6605460., 6629040., 6674766.,
      6698436., 6744432., 6768192., 7841156., 7869560., 7924096., 7952608.,
      8007468., 8036088., 8091272., 8120000., 6576730., 6600580., 6646188.,
      6670128., 6716006., 6740036., 6786184., 6810304., 5334840., 5354064.,
      5390816., 5410112., 5447080., 5466448., 5503632., 5523072., 4439572.,
      4455832., 4486560., 4502880., 4533788., 4550168., 4581256., 4597696.,
      5580243., 5600718., 5639234., 5659784., 5698525., 5719150., 5758116.,
      5778816., 6703286., 6728036., 6774280., 6799120., 6845634., 6870564.,
      6917348., 6942368., 5641767., 5662542., 5701270., 5722120., 5761073.,
      5781998., 5821176., 5842176., 4600884., 4617624., 4648896., 4665696.,
      4697148., 4714008., 4745640., 4762560.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      343710., 347220., 352008., 355536., 360378., 363924., 368820., 372384.,
      348678., 352260., 357120., 360720., 365634., 369252., 374220., 377856.,
      353646., 357300., 362232., 365904., 370890., 374580., 379620., 383328.,
      358614., 362340., 367344., 371088., 376146., 379908., 385020., 388800.,
      363582., 367380., 372456., 376272., 381402., 385236., 390420., 394272.,
      373518., 377460., 382680., 386640., 391914., 395892., 401220., 405216.,
      378486., 382500., 387792., 391824., 397170., 401220., 406620., 410688.,
      383454., 387540., 392904., 397008., 402426., 406548., 412020., 416160.,
      388422., 392580., 398016., 402192., 407682., 411876., 417420., 421632.,
      393390., 397620., 403128., 407376., 412938., 417204., 422820., 427104.,
      403326., 407700., 413352., 417744., 423450., 427860., 433620., 438048.,
      408294., 412740., 418464., 422928., 428706., 433188., 439020., 443520.,
      413262., 417780., 423576., 428112., 433962., 438516., 444420., 448992.,
      418230., 422820., 428688., 433296., 439218., 443844., 449820., 454464.,
      423198., 427860., 433800., 438480., 444474., 449172., 455220., 459936.,
      433134., 437940., 444024., 448848., 454986., 459828., 466020., 470880.,
      438102., 442980., 449136., 454032., 460242., 465156., 471420., 476352.,
      443070., 448020., 454248., 459216., 465498., 470484., 476820., 481824.,
      448038., 453060., 459360., 464400., 470754., 475812., 482220., 487296.,
      453006., 458100., 464472., 469584., 476010., 481140., 487620., 492768.,
      462942., 468180., 474696., 479952., 486522., 491796., 498420., 503712.,
      467910., 473220., 479808., 485136., 491778., 497124., 503820., 509184.,
      472878., 478260., 484920., 490320., 497034., 502452., 509220., 514656.,
      477846., 483300., 490032., 495504., 502290., 507780., 514620., 520128.,
      482814., 488340., 495144., 500688., 507546., 513108., 520020., 525600.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3295844., 3309224., 3322604., 3335984., 3364160., 3377600., 3391040.,
      3404480., 3432956., 3446456., 3459956., 3473456., 3502232., 3515792.,
      3529352., 3542912., 4112603., 4129478., 4146353., 4163228., 4198766.,
      4215716., 4232666., 4249616., 4285529., 4302554., 4319579., 4336604.,
      4372892., 4389992., 4407092., 4424192., 4892510., 4912940., 4933370.,
      4953800., 4996520., 5017040., 5037560., 5058080., 5101250., 5121860.,
      5142470., 5163080., 5206700., 5227400., 5248100., 5268800., 4059735.,
      4076910., 4094085., 4111260., 4146922., 4164172., 4181422., 4198672.,
      4234709., 4252034., 4269359., 4286684., 4323096., 4340496., 4357896.,
      4375296., 3269828., 3283688., 3297548., 3311408., 3340192., 3354112.,
      3368032., 3381952., 3411036., 3425016., 3438996., 3452976., 3482360.,
      3496400., 3510440., 3524480., 4518488., 4535408., 4552328., 4569248.,
      4604768., 4621760., 4638752., 4655744., 4691624., 4708688., 4725752.,
      4742816., 4779056., 4796192., 4813328., 4830464., 5633810., 5655140.,
      5676470., 5697800., 5742428., 5763848., 5785268., 5806688., 5851766.,
      5873276., 5894786., 5916296., 5961824., 5983424., 6005024., 6026624.,
      6701684., 6727496., 6753308., 6779120., 6832640., 6858560., 6884480.,
      6910400., 6964460., 6990488., 7016516., 7042544., 7097144., 7123280.,
      7149416., 7175552., 5551578., 5573268., 5594958., 5616648., 5661220.,
      5683000., 5704780., 5726560., 5771582., 5793452., 5815322., 5837192.,
      5882664., 5904624., 5926584., 5948544., 4455320., 4472816., 4490312.,
      4507808., 4543648., 4561216., 4578784., 4596352., 4632552., 4650192.,
      4667832., 4685472., 4722032., 4739744., 4757456., 4775168., 5629676.,
      5650424., 5671172., 5691920., 5733920., 5754752., 5775584., 5796416.,
      5838836., 5859752., 5880668., 5901584., 5944424., 5965424., 5986424.,
      6007424., 7009937., 7036082., 7062227., 7088372., 7141010., 7167260.,
      7193510., 7219760., 7272923., 7299278., 7325633., 7351988., 7405676.,
      7432136., 7458596., 7485056., 8329850., 8361476., 8393102., 8424728.,
      8487752., 8519504., 8551256., 8583008., 8646662., 8678540., 8710418.,
      8742296., 8806580., 8838584., 8870588., 8902592., 6886821., 6913386.,
      6939951., 6966516., 7018918., 7045588., 7072258., 7098928., 7151855.,
      7178630., 7205405., 7232180., 7285632., 7312512., 7339392., 7366272.,
      5510924., 5532344., 5553764., 5575184., 5617216., 5638720., 5660224.,
      5681728., 5724180., 5745768., 5767356., 5788944., 5831816., 5853488.,
      5875160., 5896832., 4759064., 4777712., 4796360., 4815008., 4851488.,
      4870208., 4888928., 4907648., 4944488., 4963280., 4982072., 5000864.,
      5038064., 5056928., 5075792., 5094656., 5952194., 5975684., 5999174.,
      6022664., 6068492., 6092072., 6115652., 6139232., 6185510., 6209180.,
      6232850., 6256520., 6303248., 6327008., 6350768., 6374528., 7090196.,
      7118600., 7147004., 7175408., 7230368., 7258880., 7287392., 7315904.,
      7371404., 7400024., 7428644., 7457264., 7513304., 7542032., 7570760.,
      7599488., 5880714., 5904564., 5928414., 5952264., 5998036., 6021976.,
      6045916., 6069856., 6116078., 6140108., 6164138., 6188168., 6234840.,
      6258960., 6283080., 6307200., 4732760., 4751984., 4771208., 4790432.,
      4827232., 4846528., 4865824., 4885120., 4922280., 4941648., 4961016.,
      4980384., 5017904., 5037344., 5056784., 5076224., 4202660., 4218920.,
      4235180., 4251440., 4283264., 4299584., 4315904., 4332224., 4364348.,
      4380728., 4397108., 4413488., 4445912., 4462352., 4478792., 4495232.,
      5206443., 5226918., 5247393., 5267868., 5307454., 5328004., 5348554.,
      5369104., 5409065., 5429690., 5450315., 5470940., 5511276., 5531976.,
      5552676., 5573376., 6160574., 6185324., 6210074., 6234824., 6281992.,
      6306832., 6331672., 6356512., 6404130., 6429060., 6453990., 6478920.,
      6526988., 6552008., 6577028., 6602048., 5105447., 5126222., 5146997.,
      5167772., 5206970., 5227820., 5248670., 5269520., 5309093., 5330018.,
      5350943., 5371868., 5411816., 5432816., 5453816., 5474816., 4103940.,
      4120680., 4137420., 4154160., 4185568., 4202368., 4219168., 4235968.,
      4267676., 4284536., 4301396., 4318256., 4350264., 4367184., 4384104.,
      4401024.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      683910.,  687420.,  690930.,  694440.,  700488.,  704016.,  707544.,
      711072.,  717210.,  720756.,  724302.,  727848.,  734076.,  737640.,
      741204.,  744768.,  693774.,  697356.,  700938.,  704520.,  710640.,
      714240.,  717840.,  721440.,  727650.,  731268.,  734886.,  738504.,
      744804.,  748440.,  752076.,  755712.,  703638.,  707292.,  710946.,
      714600.,  720792.,  724464.,  728136.,  731808.,  738090.,  741780.,
      745470.,  749160.,  755532.,  759240.,  762948.,  766656.,  713502.,
      717228.,  720954.,  724680.,  730944.,  734688.,  738432.,  742176.,
      748530.,  752292.,  756054.,  759816.,  766260.,  770040.,  773820.,
      777600.,  723366.,  727164.,  730962.,  734760.,  741096.,  744912.,
      748728.,  752544.,  758970.,  762804.,  766638.,  770472.,  776988.,
      780840.,  784692.,  788544.,  743094.,  747036.,  750978.,  754920.,
      761400.,  765360.,  769320.,  773280.,  779850.,  783828.,  787806.,
      791784.,  798444.,  802440.,  806436.,  810432.,  752958.,  756972.,
      760986.,  765000.,  771552.,  775584.,  779616.,  783648.,  790290.,
      794340.,  798390.,  802440.,  809172.,  813240.,  817308.,  821376.,
      762822.,  766908.,  770994.,  775080.,  781704.,  785808.,  789912.,
      794016.,  800730.,  804852.,  808974.,  813096.,  819900.,  824040.,
      828180.,  832320.,  772686.,  776844.,  781002.,  785160.,  791856.,
      796032.,  800208.,  804384.,  811170.,  815364.,  819558.,  823752.,
      830628.,  834840.,  839052.,  843264.,  782550.,  786780.,  791010.,
      795240.,  802008.,  806256.,  810504.,  814752.,  821610.,  825876.,
      830142.,  834408.,  841356.,  845640.,  849924.,  854208.,  802278.,
      806652.,  811026.,  815400.,  822312.,  826704.,  831096.,  835488.,
      842490.,  846900.,  851310.,  855720.,  862812.,  867240.,  871668.,
      876096.,  812142.,  816588.,  821034.,  825480.,  832464.,  836928.,
      841392.,  845856.,  852930.,  857412.,  861894.,  866376.,  873540.,
      878040.,  882540.,  887040.,  822006.,  826524.,  831042.,  835560.,
      842616.,  847152.,  851688.,  856224.,  863370.,  867924.,  872478.,
      877032.,  884268.,  888840.,  893412.,  897984.,  831870.,  836460.,
      841050.,  845640.,  852768.,  857376.,  861984.,  866592.,  873810.,
      878436.,  883062.,  887688.,  894996.,  899640.,  904284.,  908928.,
      841734.,  846396.,  851058.,  855720.,  862920.,  867600.,  872280.,
      876960.,  884250.,  888948.,  893646.,  898344.,  905724.,  910440.,
      915156.,  919872.,  861462.,  866268.,  871074.,  875880.,  883224.,
      888048.,  892872.,  897696.,  905130.,  909972.,  914814.,  919656.,
      927180.,  932040.,  936900.,  941760.,  871326.,  876204.,  881082.,
      885960.,  893376.,  898272.,  903168.,  908064.,  915570.,  920484.,
      925398.,  930312.,  937908.,  942840.,  947772.,  952704.,  881190.,
      886140.,  891090.,  896040.,  903528.,  908496.,  913464.,  918432.,
      926010.,  930996.,  935982.,  940968.,  948636.,  953640.,  958644.,
      963648.,  891054.,  896076.,  901098.,  906120.,  913680.,  918720.,
      923760.,  928800.,  936450.,  941508.,  946566.,  951624.,  959364.,
      964440.,  969516.,  974592.,  900918.,  906012.,  911106.,  916200.,
      923832.,  928944.,  934056.,  939168.,  946890.,  952020.,  957150.,
      962280.,  970092.,  975240.,  980388.,  985536.,  920646.,  925884.,
      931122.,  936360.,  944136.,  949392.,  954648.,  959904.,  967770.,
      973044.,  978318.,  983592.,  991548.,  996840.,  1002132., 1007424.,
      930510.,  935820.,  941130.,  946440.,  954288.,  959616.,  964944.,
      970272.,  978210.,  983556.,  988902.,  994248.,  1002276., 1007640.,
      1013004., 1018368., 940374.,  945756.,  951138.,  956520.,  964440.,
      969840.,  975240.,  980640.,  988650.,  994068.,  999486.,  1004904.,
      1013004., 1018440., 1023876., 1029312., 950238.,  955692.,  961146.,
      966600.,  974592.,  980064.,  985536.,  991008.,  999090.,  1004580.,
      1010070., 1015560., 1023732., 1029240., 1034748., 1040256., 960102.,
      965628.,  971154.,  976680.,  984744.,  990288.,  995832.,  1001376.,
      1009530., 1015092., 1020654., 1026216., 1034460., 1040040., 1045620.,
      1051200.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      533450., 640920., 748615., 642180., 535550., 648120.,  778302.,
      908628., 779058., 649380., 763735., 916692., 1069670., 916692.,
      763735., 649380., 779058., 908628., 778302., 648120.,  535550.,
      642180., 748615., 640920., 533450.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30258., 30636., 31014., 31392., 31770., 32904., 33282., 33660., 34038.,
      34416., 35550., 35928., 36306., 36684., 37062., 38196., 38574., 38952.,
      39330., 39708., 40842., 41220., 41598., 41976., 42354.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1061950., 1066900., 1275855., 1281840., 1490195., 1497230., 1278285.,
      1284360., 1066000., 1071100., 1289985., 1296240., 1549044., 1556604.,
      1808373., 1817256., 1550448., 1558116., 1292325., 1298760., 1519805.,
      1527470., 1824123., 1833384., 2128462., 2139340., 1823997., 1833384.,
      1519595., 1527470., 1291875., 1298760., 1549800., 1558116., 1807491.,
      1817256., 1548180., 1556604., 1289175., 1296240., 1065100., 1071100.,
      1277115., 1284360., 1488725., 1497230., 1274505., 1281840., 1060750.,
      1066900.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58950., 60516., 59679., 61272., 60408., 62028., 61137., 62784., 61866.,
      63540., 64053., 65808., 64782., 66564., 65511., 67320., 66240., 68076.,
      66969., 68832., 69156., 71100., 69885., 71856., 70614., 72612., 71343.,
      73368., 72072., 74124., 74259., 76392., 74988., 77148., 75717., 77904.,
      76446., 78660., 77175., 79416., 79362., 81684., 80091., 82440., 80820.,
      83196., 81549., 83952., 82278., 84708.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2118950., 2123900., 2128850., 2133800., 2545725., 2551710., 2557695.,
      2563680., 2973355., 2980390., 2987425., 2994460., 2550495., 2556570.,
      2562645., 2568720., 2126900., 2132000., 2137100., 2142200., 2573715.,
      2579970., 2586225., 2592480., 3090528., 3098088., 3105648., 3113208.,
      3607863., 3616746., 3625629., 3634512., 3093228., 3100896., 3108564.,
      3116232., 2578215., 2584650., 2591085., 2597520., 3031945., 3039610.,
      3047275., 3054940., 3638985., 3648246., 3657507., 3666768., 4246046.,
      4256924., 4267802., 4278680., 3638607., 3647994., 3657381., 3666768.,
      3031315., 3039190., 3047065., 3054940., 2576865., 2583750., 2590635.,
      2597520., 3091284., 3099600., 3107916., 3116232., 3605217., 3614982.,
      3624747., 3634512., 3087936., 3096360., 3104784., 3113208., 2571285.,
      2578350., 2585415., 2592480., 2124200., 2130200., 2136200., 2142200.,
      2546985., 2554230., 2561475., 2568720., 2968945., 2977450., 2985955.,
      2994460., 2541675., 2549010., 2556345., 2563680., 2115350., 2121500.,
      2127650., 2133800.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      116334., 117900., 119466., 121032., 117765., 119358., 120951., 122544.,
      119196., 120816., 122436., 124056., 120627., 122274., 123921., 125568.,
      122058., 123732., 125406., 127080., 126351., 128106., 129861., 131616.,
      127782., 129564., 131346., 133128., 129213., 131022., 132831., 134640.,
      130644., 132480., 134316., 136152., 132075., 133938., 135801., 137664.,
      136368., 138312., 140256., 142200., 137799., 139770., 141741., 143712.,
      139230., 141228., 143226., 145224., 140661., 142686., 144711., 146736.,
      142092., 144144., 146196., 148248., 146385., 148518., 150651., 152784.,
      147816., 149976., 152136., 154296., 149247., 151434., 153621., 155808.,
      150678., 152892., 155106., 157320., 152109., 154350., 156591., 158832.,
      156402., 158724., 161046., 163368., 157833., 160182., 162531., 164880.,
      159264., 161640., 164016., 166392., 160695., 163098., 165501., 167904.,
      162126., 164556., 166986., 169416.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2111675., 2133800., 2537130., 2563680., 2963485., 2994460., 2542170.,
      2568720., 2120075., 2142200., 2565930., 2592480., 3081348., 3113208.,
      3597342., 3634512., 3084372., 3116232., 2570970., 2597520., 3023965.,
      3054940., 3629598., 3666768., 4235315., 4278680., 3629598., 3666768.,
      3023965., 3054940., 2570970., 2597520., 3084372., 3116232., 3597342.,
      3634512., 3081348., 3113208., 2565930., 2592480., 2120075., 2142200.,
      2542170., 2568720., 2963485., 2994460., 2537130., 2563680., 2111675.,
      2133800.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      117171., 121032., 118629., 122544., 120087., 124056., 121545., 125568.,
      123003., 127080., 127377., 131616., 128835., 133128., 130293., 134640.,
      131751., 136152., 133209., 137664., 137583., 142200., 139041., 143712.,
      140499., 145224., 141957., 146736., 143415., 148248., 147789., 152784.,
      149247., 154296., 150705., 155808., 152163., 157320., 153621., 158832.,
      157995., 163368., 159453., 164880., 160911., 166392., 162369., 167904.,
      163827., 169416.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4213525., 4223350., 4257700., 4267600., 5062380., 5074260., 5115390.,
      5127360., 5913005., 5926970., 5974850., 5988920., 5072280., 5084340.,
      5125290., 5137440., 4230025., 4240150., 4274200., 4284400., 5119440.,
      5131860., 5172450., 5184960., 6147684., 6162696., 6211296., 6226416.,
      7177044., 7194684., 7251258., 7269024., 6153516., 6168744., 6217128.,
      6232464., 5129160., 5141940., 5182170., 5195040., 6032705., 6047930.,
      6094550., 6109880., 7240800., 7259196., 7315014., 7333536., 8449021.,
      8470630., 8535604., 8557360., 7240548., 7259196., 7314762., 7333536.,
      6032285., 6047930., 6094130., 6109880., 5128260., 5141940., 5181270.,
      5195040., 6152220., 6168744., 6215832., 6232464., 7175280., 7194684.,
      7249494., 7269024., 6145956., 6162696., 6209568., 6226416., 5117820.,
      5131860., 5170830., 5184960., 4228225., 4240150., 4272400., 4284400.,
      5069940., 5084340., 5122950., 5137440., 5910065., 5926970., 5971910.,
      5988920., 5059680., 5074260., 5112690., 5127360., 4211125., 4223350.,
      4255300., 4267600.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      231237., 234342., 238932., 242064., 234099., 237258., 241902., 245088.,
      236961., 240174., 244872., 248112., 239823., 243090., 247842., 251136.,
      242685., 246006., 250812., 254160., 251271., 254754., 259722., 263232.,
      254133., 257670., 262692., 266256., 256995., 260586., 265662., 269280.,
      259857., 263502., 268632., 272304., 262719., 266418., 271602., 275328.,
      271305., 275166., 280512., 284400., 274167., 278082., 283482., 287424.,
      277029., 280998., 286452., 290448., 279891., 283914., 289422., 293472.,
      282753., 286830., 292392., 296496., 291339., 295578., 301302., 305568.,
      294201., 298494., 304272., 308592., 297063., 301410., 307242., 311616.,
      299925., 304326., 310212., 314640., 302787., 307242., 313182., 317664.,
      311373., 315990., 322092., 326736., 314235., 318906., 325062., 329760.,
      317097., 321822., 328032., 332784., 319959., 324738., 331002., 335808.,
      322821., 327654., 333972., 338832.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4684745.,  4694570.,  4704395.,  4714220.,  4757660.,  4767560.,
      4777460.,  4787360.,  5845872.,  5857752.,  5869632.,  5881512.,
      5934394.,  5946364.,  5958334.,  5970304.,  7006413.,  7020378.,
      7034343.,  7048308.,  7110542.,  7124612.,  7138682.,  7152752.,
      6065172.,  6077232.,  6089292.,  6101352.,  6154718.,  6166868.,
      6179018.,  6191168.,  5127045.,  5137170.,  5147295.,  5157420.,
      5202008.,  5212208.,  5222408.,  5232608.,  6278940.,  6291360.,
      6303780.,  6316200.,  6369510.,  6382020.,  6394530.,  6407040.,
      7769636.,  7784648.,  7799660.,  7814672.,  7879344.,  7894464.,
      7909584.,  7924704.,  9258432.,  9276072.,  9293712.,  9311352.,
      9387278.,  9405044.,  9422810.,  9440576.,  7995100.,  8010328.,
      8025556.,  8040784.,  8105832.,  8121168.,  8136504.,  8151840.,
      6736292.,  6749072.,  6761852.,  6774632.,  6828910.,  6841780.,
      6854650.,  6867520.,  7887625.,  7902850.,  7918075.,  7933300.,
      7995850.,  8011180.,  8026510.,  8041840.,  9708772.,  9727168.,
      9745564.,  9763960.,  9839666.,  9858188.,  9876710.,  9895232.,
      11526033., 11547642., 11569251., 11590860., 11679596., 11701352.,
      11723108., 11744864., 9936368.,  9955016.,  9973664.,  9992312.,
      10068286., 10087060., 10105834., 10124608., 8353309.,  8368954.,
      8384599.,  8400244.,  8463582.,  8479332.,  8495082.,  8510832.,
      7396120.,  7409800.,  7423480.,  7437160.,  7491810.,  7505580.,
      7519350.,  7533120.,  9132972.,  9149496.,  9166020.,  9182544.,
      9248824.,  9265456.,  9282088.,  9298720.,  10865940., 10885344.,
      10904748., 10924152., 11001954., 11021484., 11041014., 11060544.,
      9375204.,  9391944.,  9408684.,  9425424.,  9492080.,  9508928.,
      9525776.,  9542624.,  7890976.,  7905016.,  7919056.,  7933096.,
      7988714.,  8002844.,  8016974.,  8031104.,  6985325.,  6997250.,
      7009175.,  7021100.,  7068480.,  7080480.,  7092480.,  7104480.,
      8656040.,  8670440.,  8684840.,  8699240.,  8756850.,  8771340.,
      8785830.,  8800320.,  10323545., 10340450., 10357355., 10374260.,
      10442010., 10459020., 10476030., 10493040., 8916940.,  8931520.,
      8946100.,  8960680.,  9018774.,  9033444.,  9048114.,  9062784.,
      7516073.,  7528298.,  7540523.,  7552748.,  7601276.,  7613576.,
      7625876.,  7638176.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      459369., 462474., 465579., 468684., 474732., 477864., 480996., 484128.,
      465039., 468198., 471357., 474516., 480618., 483804., 486990., 490176.,
      470709., 473922., 477135., 480348., 486504., 489744., 492984., 496224.,
      476379., 479646., 482913., 486180., 492390., 495684., 498978., 502272.,
      482049., 485370., 488691., 492012., 498276., 501624., 504972., 508320.,
      499059., 502542., 506025., 509508., 515934., 519444., 522954., 526464.,
      504729., 508266., 511803., 515340., 521820., 525384., 528948., 532512.,
      510399., 513990., 517581., 521172., 527706., 531324., 534942., 538560.,
      516069., 519714., 523359., 527004., 533592., 537264., 540936., 544608.,
      521739., 525438., 529137., 532836., 539478., 543204., 546930., 550656.,
      538749., 542610., 546471., 550332., 557136., 561024., 564912., 568800.,
      544419., 548334., 552249., 556164., 563022., 566964., 570906., 574848.,
      550089., 554058., 558027., 561996., 568908., 572904., 576900., 580896.,
      555759., 559782., 563805., 567828., 574794., 578844., 582894., 586944.,
      561429., 565506., 569583., 573660., 580680., 584784., 588888., 592992.,
      578439., 582678., 586917., 591156., 598338., 602604., 606870., 611136.,
      584109., 588402., 592695., 596988., 604224., 608544., 612864., 617184.,
      589779., 594126., 598473., 602820., 610110., 614484., 618858., 623232.,
      595449., 599850., 604251., 608652., 615996., 620424., 624852., 629280.,
      601119., 605574., 610029., 614484., 621882., 626364., 630846., 635328.,
      618129., 622746., 627363., 631980., 639540., 644184., 648828., 653472.,
      623799., 628470., 633141., 637812., 645426., 650124., 654822., 659520.,
      629469., 634194., 638919., 643644., 651312., 656064., 660816., 665568.,
      635139., 639918., 644697., 649476., 657198., 662004., 666810., 671616.,
      640809., 645642., 650475., 655308., 663084., 667944., 672804., 677664.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4571891.,  4606700.,  4641659.,  4676768., 5700170., 5742248., 5784506.,
      5826944.,  6830001.,  6879348.,  6928905., 6978672., 5900554., 5942632.,
      5984890.,  6027328.,  4974131.,  5008940., 5043899., 5079008., 6041674.,
      6082728.,  6123962.,  6165376.,  7486572., 7536144., 7585932., 7635936.,
      8933774.,  8991864.,  9050206.,  9108800., 7719852., 7769424., 7819212.,
      7869216.,  6508298.,  6549352.,  6590586., 6632000., 7598257., 7645556.,
      7693065.,  7740784.,  9375118.,  9432184., 9489502., 9547072., 11154363.,
      11221196., 11288323., 11355744., 9375118., 9432184., 9489502., 9547072.,
      7598257.,  7645556.,  7693065.,  7740784., 6508298., 6549352., 6590586.,
      6632000.,  7719852.,  7769424.,  7819212., 7869216., 8933774., 8991864.,
      9050206.,  9108800.,  7486572.,  7536144., 7585932., 7635936., 6041674.,
      6082728.,  6123962.,  6165376.,  4974131., 5008940., 5043899., 5079008.,
      5900554.,  5942632.,  5984890.,  6027328., 6830001., 6879348., 6928905.,
      6978672.,  5700170.,  5742248.,  5784506., 5826944., 4571891., 4606700.,
      4641659.,  4676768.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      461043., 468684., 476379., 484128., 466767., 474516., 482319., 490176.,
      472491., 480348., 488259., 496224., 478215., 486180., 494199., 502272.,
      483939., 492012., 500139., 508320., 501111., 509508., 517959., 526464.,
      506835., 515340., 523899., 532512., 512559., 521172., 529839., 538560.,
      518283., 527004., 535779., 544608., 524007., 532836., 541719., 550656.,
      541179., 550332., 559539., 568800., 546903., 556164., 565479., 574848.,
      552627., 561996., 571419., 580896., 558351., 567828., 577359., 586944.,
      564075., 573660., 583299., 592992., 581247., 591156., 601119., 611136.,
      586971., 596988., 607059., 617184., 592695., 602820., 612999., 623232.,
      598419., 608652., 618939., 629280., 604143., 614484., 624879., 635328.,
      621315., 631980., 642699., 653472., 627039., 637812., 648639., 659520.,
      632763., 643644., 654579., 665568., 638487., 649476., 660519., 671616.,
      644211., 655308., 666459., 677664.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3660143., 3678182., 3711766., 3729880., 3763689.,  3781878.,  3815912.,
      3834176., 4547102., 4568724., 4609152., 4630864.,  4671562.,  4693364.,
      4734332., 4756224., 5521585., 5546850., 5594574.,  5619944.,  5667983.,
      5693458., 5741812., 5767392., 4728886., 4750356.,  4790936.,  4812496.,
      4853346., 4874996., 4916116., 4937856., 3956631.,  3974246.,  4007742.,
      4025432., 4059153., 4076918., 4110864., 4128704.,  5068774.,  5089428.,
      5130312., 5151056., 5192210., 5213044., 5254468.,  5275392.,  6262268.,
      6287064., 6336216., 6361120., 6410596., 6435608.,  6485408.,  6510528.,
      7557066., 7586076., 7643936., 7673072., 7731310.,  7760572.,  7819188.,
      7848576., 6497484., 6522200., 6571432., 6596256.,  6645812.,  6670744.,
      6720624., 6745664., 5459094., 5479444., 5520120.,  5540560.,  5581506.,
      5602036., 5643252., 5663872., 6578905., 6602594.,  6650358.,  6674152.,
      6722231., 6746130., 6794524., 6818528., 8095202.,  8123676.,  8181048.,
      8209648., 8267398., 8296124., 8354252., 8383104.,  9725239.,  9758582.,
      9825990., 9859480., 9927329., 9960966., 10029256., 10063040., 8113642.,
      8142108., 8199488., 8228080., 8285838., 8314556.,  8372692.,  8401536.,
      6525329., 6548834., 6596270., 6619880., 6667631.,  6691346.,  6739412.,
      6763232., 5569934., 5590548., 5631472., 5652176.,  5693370.,  5714164.,
      5755628., 5776512., 6548652., 6573400., 6622600.,  6647456.,  6696980.,
      6721944., 6771792., 6796864., 7657474., 7686428.,  7744344.,  7773424.,
      7831718., 7860924., 7919596., 7948928., 6375036.,  6399704.,  6448984.,
      6473760., 6523364., 6548248., 6598176., 6623168.,  5113662.,  5133972.,
      5174688., 5195088., 5236074., 5256564., 5297820.,  5318400.,  4268935.,
      4286054., 4320558., 4337752., 4372481., 4389750.,  4424704.,  4442048.,
      5022702., 5043220., 5084752., 5105360., 5147162.,  5167860.,  5209932.,
      5230720., 5924281., 5948258., 5997270., 6021352.,  6070679.,  6094866.,
      6144508., 6168800., 4927238., 4947604., 4989288.,  5009744.,  5051698.,
      5072244., 5114468., 5135104., 3947695., 3964390.,  3998806.,  4015576.,
      4050217., 4067062., 4101928., 4118848.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      915903.,  922086.,  931158.,  937368.,  946521.,  952758.,  961992.,
      968256.,  927243.,  933534.,  942714.,  949032.,  958293.,  964638.,
      973980.,  980352.,  938583.,  944982.,  954270.,  960696.,  970065.,
      976518.,  985968.,  992448.,  949923.,  956430.,  965826.,  972360.,
      981837.,  988398.,  997956.,  1004544., 961263.,  967878.,  977382.,
      984024.,  993609.,  1000278., 1009944., 1016640., 995283.,  1002222.,
      1012050., 1019016., 1028925., 1035918., 1045908., 1052928., 1006623.,
      1013670., 1023606., 1030680., 1040697., 1047798., 1057896., 1065024.,
      1017963., 1025118., 1035162., 1042344., 1052469., 1059678., 1069884.,
      1077120., 1029303., 1036566., 1046718., 1054008., 1064241., 1071558.,
      1081872., 1089216., 1040643., 1048014., 1058274., 1065672., 1076013.,
      1083438., 1093860., 1101312., 1074663., 1082358., 1092942., 1100664.,
      1111329., 1119078., 1129824., 1137600., 1086003., 1093806., 1104498.,
      1112328., 1123101., 1130958., 1141812., 1149696., 1097343., 1105254.,
      1116054., 1123992., 1134873., 1142838., 1153800., 1161792., 1108683.,
      1116702., 1127610., 1135656., 1146645., 1154718., 1165788., 1173888.,
      1120023., 1128150., 1139166., 1147320., 1158417., 1166598., 1177776.,
      1185984., 1154043., 1162494., 1173834., 1182312., 1193733., 1202238.,
      1213740., 1222272., 1165383., 1173942., 1185390., 1193976., 1205505.,
      1214118., 1225728., 1234368., 1176723., 1185390., 1196946., 1205640.,
      1217277., 1225998., 1237716., 1246464., 1188063., 1196838., 1208502.,
      1217304., 1229049., 1237878., 1249704., 1258560., 1199403., 1208286.,
      1220058., 1228968., 1240821., 1249758., 1261692., 1270656., 1233423.,
      1242630., 1254726., 1263960., 1276137., 1285398., 1297656., 1306944.,
      1244763., 1254078., 1266282., 1275624., 1287909., 1297278., 1309644.,
      1319040., 1256103., 1265526., 1277838., 1287288., 1299681., 1309158.,
      1321632., 1331136., 1267443., 1276974., 1289394., 1298952., 1311453.,
      1321038., 1333620., 1343232., 1278783., 1288422., 1300950., 1310616.,
      1323225., 1332918., 1345608., 1355328.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4192871., 4210910., 4228949., 4246988., 4283242., 4301356., 4319470.,
      4337584., 4374213., 4392402., 4410591., 4428780., 4465784., 4484048.,
      4502312., 4520576., 5163974., 5185596., 5207218., 5228840., 5272624.,
      5294336., 5316048., 5337760., 5381994., 5403796., 5425598., 5447400.,
      5492084., 5513976., 5535868., 5557760., 6198961., 6224226., 6249491.,
      6274756., 6326402., 6351772., 6377142., 6402512., 6454683., 6480158.,
      6505633., 6531108., 6583804., 6609384., 6634964., 6660544., 5335182.,
      5356652., 5378122., 5399592., 5443832., 5465392., 5486952., 5508512.,
      5553202., 5574852., 5596502., 5618152., 5663292., 5685032., 5706772.,
      5728512., 4524639., 4542254., 4559869., 4577484., 4614498., 4632188.,
      4649878., 4667568., 4704957., 4722722., 4740487., 4758252., 4796016.,
      4813856., 4831696., 4849536., 5097758., 5118412., 5139066., 5159720.,
      5202824., 5223568., 5244312., 5265056., 5308610., 5329444., 5350278.,
      5371112., 5415116., 5436040., 5456964., 5477888., 6287132., 6311928.,
      6336724., 6361520., 6413416., 6438320., 6463224., 6488128., 6540564.,
      6565576., 6590588., 6615600., 6668576., 6693696., 6718816., 6743936.,
      7549506., 7578516., 7607526., 7636536., 7697520., 7726656., 7755792.,
      7784928., 7846542., 7875804., 7905066., 7934328., 7996572., 8025960.,
      8055348., 8084736., 6540556., 6565272., 6589988., 6614704., 6666840.,
      6691664., 6716488., 6741312., 6793988., 6818920., 6843852., 6868784.,
      6922000., 6947040., 6972080., 6997120., 5590446., 5610796., 5631146.,
      5651496., 5695000., 5715440., 5735880., 5756320., 5800274., 5820804.,
      5841334., 5861864., 5906268., 5926888., 5947508., 5968128., 6061865.,
      6085554., 6109243., 6132932., 6181626., 6205420., 6229214., 6253008.,
      6302227., 6326126., 6350025., 6373924., 6423668., 6447672., 6471676.,
      6495680., 7473290., 7501764., 7530238., 7558712., 7617208., 7645808.,
      7674408., 7703008., 7762134., 7790860., 7819586., 7848312., 7908068.,
      7936920., 7965772., 7994624., 8964143., 8997486., 9030829., 9064172.,
      9132730., 9166220., 9199710., 9233200., 9302493., 9336130., 9369767.,
      9403404., 9473432., 9507216., 9541000., 9574784., 7530658., 7559124.,
      7587590., 7616056., 7674576., 7703168., 7731760., 7760352., 7819502.,
      7848220., 7876938., 7905656., 7965436., 7994280., 8023124., 8051968.,
      6164305., 6187810., 6211315., 6234820., 6283554., 6307164., 6330774.,
      6354384., 6403643., 6427358., 6451073., 6474788., 6524572., 6548392.,
      6572212., 6596032., 5129878., 5150492., 5171106., 5191720., 5233408.,
      5254112., 5274816., 5295520., 5337658., 5358452., 5379246., 5400040.,
      5442628., 5463512., 5484396., 5505280., 5977260., 6002008., 6026756.,
      6051504., 6101496., 6126352., 6151208., 6176064., 6226596., 6251560.,
      6276524., 6301488., 6352560., 6377632., 6402704., 6427776., 6924522.,
      6953476., 6982430., 7011384., 7069976., 7099056., 7128136., 7157216.,
      7216438., 7245644., 7274850., 7304056., 7363908., 7393240., 7422572.,
      7451904., 5717660., 5742328., 5766996., 5791664., 5841384., 5866160.,
      5890936., 5915712., 5965972., 5990856., 6015740., 6040624., 6091424.,
      6116416., 6141408., 6166400., 4569382., 4589692., 4610002., 4630312.,
      4671376., 4691776., 4712176., 4732576., 4774090., 4794580., 4815070.,
      4835560., 4877524., 4898104., 4918684., 4939264., 3822127., 3839246.,
      3856365., 3873484., 3908402., 3925596., 3942790., 3959984., 3995277.,
      4012546., 4029815., 4047084., 4082752., 4100096., 4117440., 4134784.,
      4478902., 4499420., 4519938., 4540456., 4582432., 4603040., 4623648.,
      4644256., 4686682., 4707380., 4728078., 4748776., 4791652., 4812440.,
      4833228., 4854016., 5258697., 5282674., 5306651., 5330628., 5379994.,
      5404076., 5428158., 5452240., 5502131., 5526318., 5550505., 5574692.,
      5625108., 5649400., 5673692., 5697984., 4373630., 4393996., 4414362.,
      4434728., 4476648., 4497104., 4517560., 4538016., 4580386., 4600932.,
      4621478., 4642024., 4684844., 4705480., 4726116., 4746752., 3537959.,
      3554654., 3571349., 3588044., 3622698., 3639468., 3656238., 3673008.,
      3708037., 3724882., 3741727., 3758572., 3793976., 3810896., 3827816.,
      3844736.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1825623., 1831806., 1837989., 1844172., 1856106., 1862316., 1868526.,
      1874736., 1886805., 1893042., 1899279., 1905516., 1917720., 1923984.,
      1930248., 1936512., 1848195., 1854486., 1860777., 1867068., 1879110.,
      1885428., 1891746., 1898064., 1910241., 1916586., 1922931., 1929276.,
      1941588., 1947960., 1954332., 1960704., 1870767., 1877166., 1883565.,
      1889964., 1902114., 1908540., 1914966., 1921392., 1933677., 1940130.,
      1946583., 1953036., 1965456., 1971936., 1978416., 1984896., 1893339.,
      1899846., 1906353., 1912860., 1925118., 1931652., 1938186., 1944720.,
      1957113., 1963674., 1970235., 1976796., 1989324., 1995912., 2002500.,
      2009088., 1915911., 1922526., 1929141., 1935756., 1948122., 1954764.,
      1961406., 1968048., 1980549., 1987218., 1993887., 2000556., 2013192.,
      2019888., 2026584., 2033280., 1983627., 1990566., 1997505., 2004444.,
      2017134., 2024100., 2031066., 2038032., 2050857., 2057850., 2064843.,
      2071836., 2084796., 2091816., 2098836., 2105856., 2006199., 2013246.,
      2020293., 2027340., 2040138., 2047212., 2054286., 2061360., 2074293.,
      2081394., 2088495., 2095596., 2108664., 2115792., 2122920., 2130048.,
      2028771., 2035926., 2043081., 2050236., 2063142., 2070324., 2077506.,
      2084688., 2097729., 2104938., 2112147., 2119356., 2132532., 2139768.,
      2147004., 2154240., 2051343., 2058606., 2065869., 2073132., 2086146.,
      2093436., 2100726., 2108016., 2121165., 2128482., 2135799., 2143116.,
      2156400., 2163744., 2171088., 2178432., 2073915., 2081286., 2088657.,
      2096028., 2109150., 2116548., 2123946., 2131344., 2144601., 2152026.,
      2159451., 2166876., 2180268., 2187720., 2195172., 2202624., 2141631.,
      2149326., 2157021., 2164716., 2178162., 2185884., 2193606., 2201328.,
      2214909., 2222658., 2230407., 2238156., 2251872., 2259648., 2267424.,
      2275200., 2164203., 2172006., 2179809., 2187612., 2201166., 2208996.,
      2216826., 2224656., 2238345., 2246202., 2254059., 2261916., 2275740.,
      2283624., 2291508., 2299392., 2186775., 2194686., 2202597., 2210508.,
      2224170., 2232108., 2240046., 2247984., 2261781., 2269746., 2277711.,
      2285676., 2299608., 2307600., 2315592., 2323584., 2209347., 2217366.,
      2225385., 2233404., 2247174., 2255220., 2263266., 2271312., 2285217.,
      2293290., 2301363., 2309436., 2323476., 2331576., 2339676., 2347776.,
      2231919., 2240046., 2248173., 2256300., 2270178., 2278332., 2286486.,
      2294640., 2308653., 2316834., 2325015., 2333196., 2347344., 2355552.,
      2363760., 2371968., 2299635., 2308086., 2316537., 2324988., 2339190.,
      2347668., 2356146., 2364624., 2378961., 2387466., 2395971., 2404476.,
      2418948., 2427480., 2436012., 2444544., 2322207., 2330766., 2339325.,
      2347884., 2362194., 2370780., 2379366., 2387952., 2402397., 2411010.,
      2419623., 2428236., 2442816., 2451456., 2460096., 2468736., 2344779.,
      2353446., 2362113., 2370780., 2385198., 2393892., 2402586., 2411280.,
      2425833., 2434554., 2443275., 2451996., 2466684., 2475432., 2484180.,
      2492928., 2367351., 2376126., 2384901., 2393676., 2408202., 2417004.,
      2425806., 2434608., 2449269., 2458098., 2466927., 2475756., 2490552.,
      2499408., 2508264., 2517120., 2389923., 2398806., 2407689., 2416572.,
      2431206., 2440116., 2449026., 2457936., 2472705., 2481642., 2490579.,
      2499516., 2514420., 2523384., 2532348., 2541312., 2457639., 2466846.,
      2476053., 2485260., 2500218., 2509452., 2518686., 2527920., 2543013.,
      2552274., 2561535., 2570796., 2586024., 2595312., 2604600., 2613888.,
      2480211., 2489526., 2498841., 2508156., 2523222., 2532564., 2541906.,
      2551248., 2566449., 2575818., 2585187., 2594556., 2609892., 2619288.,
      2628684., 2638080., 2502783., 2512206., 2521629., 2531052., 2546226.,
      2555676., 2565126., 2574576., 2589885., 2599362., 2608839., 2618316.,
      2633760., 2643264., 2652768., 2662272., 2525355., 2534886., 2544417.,
      2553948., 2569230., 2578788., 2588346., 2597904., 2613321., 2622906.,
      2632491., 2642076., 2657628., 2667240., 2676852., 2686464., 2547927.,
      2557566., 2567205., 2576844., 2592234., 2601900., 2611566., 2621232.,
      2636757., 2646450., 2656143., 2665836., 2681496., 2691216., 2700936.,
      2710656.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      835275.,  975520.,  1116020., 977200.,  838155.,  1014714., 1184568.,
      1354584., 1185576., 1016442., 1195593., 1395128., 1594684., 1395128.,
      1195593., 1016442., 1185576., 1354584., 1184568., 1014714., 838155.,
      977200.,  1116020., 975520.,  835275.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61230., 61896., 62562., 63228., 63894., 66558., 67224., 67890., 68556.,
      69222., 71886., 72552., 73218., 73884., 74550., 77214., 77880., 78546.,
      79212., 79878., 82542., 83208., 83874., 84540., 85206.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1663755., 1670550., 1943060., 1951040., 2222860., 2232040., 1946315.,
      1954400., 1669335., 1676310., 2020842., 2029428., 2359056., 2369136.,
      2697576., 2709168., 2360946., 2371152., 2024082., 2032884., 2380665.,
      2391186., 2777908., 2790256., 3175172., 3189368., 2777761., 2790256.,
      2380413., 2391186., 2023434., 2032884., 2360064., 2371152., 2696424.,
      2709168., 2357922., 2369136., 2019762., 2029428., 1668075., 1676310.,
      1944740., 1954400., 2220940., 2232040., 1941275., 1951040., 1662135.,
      1670550.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120066., 122460., 121362., 123792., 122658., 125124., 123954., 126456.,
      125250., 127788., 130434., 133116., 131730., 134448., 133026., 135780.,
      134322., 137112., 135618., 138444., 140802., 143772., 142098., 145104.,
      143394., 146436., 144690., 147768., 145986., 149100., 151170., 154428.,
      152466., 155760., 153762., 157092., 155058., 158424., 156354., 159756.,
      161538., 165084., 162834., 166416., 164130., 167748., 165426., 169080.,
      166722., 170412.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3320715., 3327510., 3334305., 3341100., 3878140., 3886120., 3894100.,
      3902080., 4436540., 4445720., 4454900., 4464080., 3884545., 3892630.,
      3900715., 3908800., 3331695., 3338670., 3345645., 3352620., 4033098.,
      4041684., 4050270., 4058856., 4708032., 4718112., 4728192., 4738272.,
      5383560., 5395152., 5406744., 5418336., 4711686., 4721892., 4732098.,
      4742304., 4039362., 4048164., 4056966., 4065768., 4750809., 4761330.,
      4771851., 4782372., 5543468., 5555816., 5568164., 5580512., 6336148.,
      6350344., 6364540., 6378736., 5543027., 5555522., 5568017., 5580512.,
      4750053., 4760826., 4771599., 4782372., 4037418., 4046868., 4056318.,
      4065768., 4709040., 4720128., 4731216., 4742304., 5380104., 5392848.,
      5405592., 5418336., 4704630., 4715844., 4727058., 4738272., 4029858.,
      4039524., 4049190., 4058856., 3327915., 3336150., 3344385., 3352620.,
      3879820., 3889480., 3899140., 3908800., 4430780., 4441880., 4452980.,
      4464080., 3872785., 3882550., 3892315., 3902080., 3315855., 3324270.,
      3332685., 3341100.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237738., 240132., 242526., 244920., 240294., 242724., 245154., 247584.,
      242850., 245316., 247782., 250248., 245406., 247908., 250410., 252912.,
      247962., 250500., 253038., 255576., 258186., 260868., 263550., 266232.,
      260742., 263460., 266178., 268896., 263298., 266052., 268806., 271560.,
      265854., 268644., 271434., 274224., 268410., 271236., 274062., 276888.,
      278634., 281604., 284574., 287544., 281190., 284196., 287202., 290208.,
      283746., 286788., 289830., 292872., 286302., 289380., 292458., 295536.,
      288858., 291972., 295086., 298200., 299082., 302340., 305598., 308856.,
      301638., 304932., 308226., 311520., 304194., 307524., 310854., 314184.,
      306750., 310116., 313482., 316848., 309306., 312708., 316110., 319512.,
      319530., 323076., 326622., 330168., 322086., 325668., 329250., 332832.,
      324642., 328260., 331878., 335496., 327198., 330852., 334506., 338160.,
      329754., 333444., 337134., 340824.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3310770., 3341100., 3866695., 3902080., 4423640., 4464080., 3873415.,
      3908800., 3322290., 3352620., 4022460., 4058856., 4695810., 4738272.,
      5369808., 5418336., 4699842., 4742304., 4029372., 4065768., 4739910.,
      4782372., 5530973., 5580512., 6322120., 6378736., 5530973., 5580512.,
      4739910., 4782372., 4029372., 4065768., 4699842., 4742304., 5369808.,
      5418336., 4695810., 4738272., 4022460., 4058856., 3322290., 3352620.,
      3873415., 3908800., 4423640., 4464080., 3866695., 3902080., 3310770.,
      3341100.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      238836., 244920., 241428., 247584., 244020., 250248., 246612., 252912.,
      249204., 255576., 259572., 266232., 262164., 268896., 264756., 271560.,
      267348., 274224., 269940., 276888., 280308., 287544., 282900., 290208.,
      285492., 292872., 288084., 295536., 290676., 298200., 301044., 308856.,
      303636., 311520., 306228., 314184., 308820., 316848., 311412., 319512.,
      321780., 330168., 324372., 332832., 326964., 335496., 329556., 338160.,
      332148., 340824.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6608040.,  6621540.,  6668610.,  6682200.,  7717535.,  7733390.,
      7788200.,  7804160.,  8829040.,  8847280.,  8909800.,  8928160.,
      7730765.,  7746830.,  7801430.,  7817600.,  6630720.,  6644580.,
      6691290.,  6705240.,  8027856.,  8044920.,  8100540.,  8117712.,
      9371586.,  9391620.,  9456384.,  9476544.,  10716576., 10739616.,
      10813488., 10836672., 9379398.,  9399684.,  9464196.,  9484608.,
      8041248.,  8058744.,  8113932.,  8131536.,  9458904.,  9479820.,
      9543702.,  9564744.,  11037397., 11061946., 11136328., 11161024.,
      12616016., 12644240., 12729080., 12757472., 11037103., 11061946.,
      11136034., 11161024., 9458400.,  9479820.,  9543198.,  9564744.,
      8039952.,  8058744.,  8112636.,  8131536.,  9377634.,  9399684.,
      9462432.,  9484608.,  10714272., 10739616., 10811184., 10836672.,
      9369318.,  9391620.,  9454116.,  9476544.,  8025696.,  8044920.,
      8098380.,  8117712.,  6628200.,  6644580.,  6688770.,  6705240.,
      7727615.,  7746830.,  7798280.,  7817600.,  8825200.,  8847280.,
      8905960.,  8928160.,  7713965.,  7733390.,  7784630.,  7804160.,
      6604800.,  6621540.,  6665370.,  6682200.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      472920., 477672., 485052., 489840., 478032., 482856., 490308., 495168.,
      483144., 488040., 495564., 500496., 488256., 493224., 500820., 505824.,
      493368., 498408., 506076., 511152., 513816., 519144., 527100., 532464.,
      518928., 524328., 532356., 537792., 524040., 529512., 537612., 543120.,
      529152., 534696., 542868., 548448., 534264., 539880., 548124., 553776.,
      554712., 560616., 569148., 575088., 559824., 565800., 574404., 580416.,
      564936., 570984., 579660., 585744., 570048., 576168., 584916., 591072.,
      575160., 581352., 590172., 596400., 595608., 602088., 611196., 617712.,
      600720., 607272., 616452., 623040., 605832., 612456., 621708., 628368.,
      610944., 617640., 626964., 633696., 616056., 622824., 632220., 639024.,
      636504., 643560., 653244., 660336., 641616., 648744., 658500., 665664.,
      646728., 653928., 663756., 670992., 651840., 659112., 669012., 676320.,
      656952., 664296., 674268., 681648.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5153940.,  5167440.,  5180940.,  5194440.,  5244270.,  5257860.,
      5271450.,  5285040.,  5993295.,  6009150.,  6025005.,  6040860.,
      6098680.,  6114640.,  6130600.,  6146560.,  6826400.,  6844640.,
      6862880.,  6881120.,  6946840.,  6965200.,  6983560.,  7001920.,
      5947865.,  5963930.,  5979995.,  5996060.,  6053250.,  6069420.,
      6085590.,  6101760.,  5076060.,  5089920.,  5103780.,  5117640.,
      5166390.,  5180340.,  5194290.,  5208240.,  7498488.,  7515552.,
      7532616.,  7549680.,  7613028.,  7630200.,  7647372.,  7664544.,
      8723778.,  8743812.,  8763846.,  8783880.,  8857408.,  8877568.,
      8897728.,  8917888.,  9941312.,  9964352.,  9987392.,  10010432.,
      10094032., 10117216., 10140400., 10163584., 8667470.,  8687756.,
      8708042.,  8728328.,  8801100.,  8821512.,  8841924.,  8862336.,
      7401960.,  7419456.,  7436952.,  7454448.,  7516500.,  7534104.,
      7551708.,  7569312.,  9865212.,  9886128.,  9907044.,  9927960.,
      10003962., 10025004., 10046046., 10067088., 11477445., 11501994.,
      11526543., 11551092., 11639320., 11664016., 11688712., 11713408.,
      13079648., 13107872., 13136096., 13164320., 13264648., 13293040.,
      13321432., 13349824., 11404883., 11429726., 11454569., 11479412.,
      11566758., 11591748., 11616738., 11641728., 9740820.,  9762240.,
      9783660.,  9805080.,  9879570.,  9901116.,  9922662.,  9944208.,
      8639160.,  8657952.,  8676744.,  8695536.,  8759844.,  8778744.,
      8797644.,  8816544.,  10045602., 10067652., 10089702., 10111752.,
      10186400., 10208576., 10230752., 10252928., 11441728., 11467072.,
      11492416., 11517760., 11602640., 11628128., 11653616., 11679104.,
      9971374.,  9993676.,  10015978., 10038280., 10112172., 10134600.,
      10157028., 10179456., 8511912.,  8531136.,  8550360.,  8569584.,
      8632596.,  8651928.,  8671260.,  8690592.,  7526100.,  7542480.,
      7558860.,  7575240.,  7628718.,  7645188.,  7661658.,  7678128.,
      8748271.,  8767486.,  8786701.,  8805916.,  8867992.,  8887312.,
      8906632.,  8925952.,  9960608.,  9982688.,  10004768., 10026848.,
      10097432., 10119632., 10141832., 10164032., 8677753.,  8697178.,
      8716603.,  8736028.,  8797474.,  8817004.,  8836534.,  8856064.,
      7405212.,  7421952.,  7438692.,  7455432.,  7507830.,  7524660.,
      7541490.,  7558320.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      941088.,  945840.,  950592.,  955344.,  965316.,  970104.,  974892.,
      979680.,  951240.,  956064.,  960888.,  965712.,  975756.,  980616.,
      985476.,  990336.,  961392.,  966288.,  971184.,  976080.,  986196.,
      991128.,  996060.,  1000992., 971544.,  976512.,  981480.,  986448.,
      996636.,  1001640., 1006644., 1011648., 981696.,  986736.,  991776.,
      996816.,  1007076., 1012152., 1017228., 1022304., 1022304., 1027632.,
      1032960., 1038288., 1048836., 1054200., 1059564., 1064928., 1032456.,
      1037856., 1043256., 1048656., 1059276., 1064712., 1070148., 1075584.,
      1042608., 1048080., 1053552., 1059024., 1069716., 1075224., 1080732.,
      1086240., 1052760., 1058304., 1063848., 1069392., 1080156., 1085736.,
      1091316., 1096896., 1062912., 1068528., 1074144., 1079760., 1090596.,
      1096248., 1101900., 1107552., 1103520., 1109424., 1115328., 1121232.,
      1132356., 1138296., 1144236., 1150176., 1113672., 1119648., 1125624.,
      1131600., 1142796., 1148808., 1154820., 1160832., 1123824., 1129872.,
      1135920., 1141968., 1153236., 1159320., 1165404., 1171488., 1133976.,
      1140096., 1146216., 1152336., 1163676., 1169832., 1175988., 1182144.,
      1144128., 1150320., 1156512., 1162704., 1174116., 1180344., 1186572.,
      1192800., 1184736., 1191216., 1197696., 1204176., 1215876., 1222392.,
      1228908., 1235424., 1194888., 1201440., 1207992., 1214544., 1226316.,
      1232904., 1239492., 1246080., 1205040., 1211664., 1218288., 1224912.,
      1236756., 1243416., 1250076., 1256736., 1215192., 1221888., 1228584.,
      1235280., 1247196., 1253928., 1260660., 1267392., 1225344., 1232112.,
      1238880., 1245648., 1257636., 1264440., 1271244., 1278048., 1265952.,
      1273008., 1280064., 1287120., 1299396., 1306488., 1313580., 1320672.,
      1276104., 1283232., 1290360., 1297488., 1309836., 1317000., 1324164.,
      1331328., 1286256., 1293456., 1300656., 1307856., 1320276., 1327512.,
      1334748., 1341984., 1296408., 1303680., 1310952., 1318224., 1330716.,
      1338024., 1345332., 1352640., 1306560., 1313904., 1321248., 1328592.,
      1341156., 1348536., 1355916., 1363296.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4089570.,  4125384.,  4161378.,  4197552.,  4773349.,  4815132.,
      4857125.,  4899328.,  5457112.,  5504864.,  5552856.,  5601088.,
      4771557.,  4813340.,  4855333.,  4897536.,  4086498.,  4122312.,
      4158306.,  4194480.,  6276060.,  6320880.,  6365916.,  6411168.,
      7326662.,  7378952.,  7431494.,  7484288.,  8377808.,  8437568.,
      8497616.,  8557952.,  7328454.,  7380744.,  7433286.,  7486080.,
      6279132.,  6323952.,  6368988.,  6414240.,  8583894.,  8637720.,
      8691798.,  8746128.,  10018855., 10081652., 10144743., 10208128.,
      11454152., 11525920., 11598024., 11670464., 10018855., 10081652.,
      10144743., 10208128., 8583894.,  8637720.,  8691798.,  8746128.,
      6279132.,  6323952.,  6368988.,  6414240.,  7328454.,  7380744.,
      7433286.,  7486080.,  8377808.,  8437568.,  8497616.,  8557952.,
      7326662.,  7378952.,  7431494.,  7484288.,  6276060.,  6320880.,
      6365916.,  6411168.,  4086498.,  4122312.,  4158306.,  4194480.,
      4771557.,  4813340.,  4855333.,  4897536.,  5457112.,  5504864.,
      5552856.,  5601088.,  4773349.,  4815132.,  4857125.,  4899328.,
      4089570.,  4125384.,  4161378.,  4197552.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      943284.,  955344.,  967476.,  979680.,  953508.,  965712.,  977988.,
      990336.,  963732.,  976080.,  988500.,  1000992., 973956.,  986448.,
      999012.,  1011648., 984180.,  996816.,  1009524., 1022304., 1025076.,
      1038288., 1051572., 1064928., 1035300., 1048656., 1062084., 1075584.,
      1045524., 1059024., 1072596., 1086240., 1055748., 1069392., 1083108.,
      1096896., 1065972., 1079760., 1093620., 1107552., 1106868., 1121232.,
      1135668., 1150176., 1117092., 1131600., 1146180., 1160832., 1127316.,
      1141968., 1156692., 1171488., 1137540., 1152336., 1167204., 1182144.,
      1147764., 1162704., 1177716., 1192800., 1188660., 1204176., 1219764.,
      1235424., 1198884., 1214544., 1230276., 1246080., 1209108., 1224912.,
      1240788., 1256736., 1219332., 1235280., 1251300., 1267392., 1229556.,
      1245648., 1261812., 1278048., 1270452., 1287120., 1303860., 1320672.,
      1280676., 1297488., 1314372., 1331328., 1290900., 1307856., 1324884.,
      1341984., 1301124., 1318224., 1335396., 1352640., 1311348., 1328592.,
      1345908., 1363296.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3568806.,  3586500.,  3624984.,  3642768.,  3681522.,  3699396.,
      3738420.,  3756384.,  4131925.,  4152778.,  4197466.,  4218424.,
      4263427.,  4284490.,  4329808.,  4350976.,  4684712.,  4708784.,
      4759616.,  4783808.,  4835000.,  4859312.,  4910864.,  4935296.,
      4056241.,  4077514.,  4121782.,  4143160.,  4187743.,  4209226.,
      4254124.,  4275712.,  3439062.,  3457476.,  3495240.,  3513744.,
      3551778.,  3570372.,  3608676.,  3627360.,  5314260.,  5335992.,
      5382288.,  5404128.,  5450748.,  5472696.,  5519640.,  5541696.,
      6158726.,  6184332.,  6238092.,  6263824.,  6317962.,  6343820.,
      6398336.,  6424320.,  6989872.,  7019424.,  7080576.,  7110272.,
      7171856.,  7201696.,  7263712.,  7293696.,  6061454.,  6087564.,
      6140820.,  6167056.,  6220690.,  6247052.,  6301064.,  6327552.,
      5147508.,  5170104.,  5215536.,  5238240.,  5283996.,  5306808.,
      5352888.,  5375808.,  7827138.,  7853484.,  7910088.,  7936560.,
      7993542.,  8020140.,  8077500.,  8104224.,  9082647.,  9113678.,
      9179422.,  9210600.,  9276785.,  9308110.,  9374736.,  9406208.,
      10322360., 10358160., 10432960., 10468928., 10544232., 10580368.,
      10656176., 10692480., 8967371.,  8998990.,  9064146.,  9095912.,
      9161509.,  9193422.,  9259460.,  9291520.,  7629522.,  7656876.,
      7712472.,  7739952.,  7795926.,  7823532.,  7879884.,  7907616.,
      5418324.,  5440440.,  5486352.,  5508576.,  5554812.,  5577144.,
      5623704.,  5646144.,  6276550.,  6302604.,  6355916.,  6382096.,
      6435786.,  6462092.,  6516160.,  6542592.,  7120432.,  7150496.,
      7211136.,  7241344.,  7302416.,  7332768.,  7394272.,  7424768.,
      6172110.,  6198668.,  6251476.,  6278160.,  6331346.,  6358156.,
      6411720.,  6438656.,  5239284.,  5262264.,  5307312.,  5330400.,
      5375772.,  5398968.,  5444664.,  5467968.,  3332646.,  3349956.,
      3385752.,  3403152.,  3439218.,  3456708.,  3493044.,  3510624.,
      3852821.,  3873226.,  3914778.,  3935288.,  3977155.,  3997770.,
      4039952.,  4060672.,  4361640.,  4385200.,  4432448.,  4456128.,
      4503736.,  4527536.,  4575504.,  4599424.,  3769969.,  3790794.,
      3831926.,  3852856.,  3894303.,  3915338.,  3957100.,  3978240.,
      3190614.,  3208644.,  3243720.,  3261840.,  3297186.,  3315396.,
      3351012.,  3369312.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1877100., 1886568., 1901184., 1910688., 1925412., 1934952., 1949784.,
      1959360., 1897404., 1907016., 1921776., 1931424., 1946292., 1955976.,
      1970952., 1980672., 1917708., 1927464., 1942368., 1952160., 1967172.,
      1977000., 1992120., 2001984., 1938012., 1947912., 1962960., 1972896.,
      1988052., 1998024., 2013288., 2023296., 1958316., 1968360., 1983552.,
      1993632., 2008932., 2019048., 2034456., 2044608., 2039532., 2050152.,
      2065920., 2076576., 2092452., 2103144., 2119128., 2129856., 2059836.,
      2070600., 2086512., 2097312., 2113332., 2124168., 2140296., 2151168.,
      2080140., 2091048., 2107104., 2118048., 2134212., 2145192., 2161464.,
      2172480., 2100444., 2111496., 2127696., 2138784., 2155092., 2166216.,
      2182632., 2193792., 2120748., 2131944., 2148288., 2159520., 2175972.,
      2187240., 2203800., 2215104., 2201964., 2213736., 2230656., 2242464.,
      2259492., 2271336., 2288472., 2300352., 2222268., 2234184., 2251248.,
      2263200., 2280372., 2292360., 2309640., 2321664., 2242572., 2254632.,
      2271840., 2283936., 2301252., 2313384., 2330808., 2342976., 2262876.,
      2275080., 2292432., 2304672., 2322132., 2334408., 2351976., 2364288.,
      2283180., 2295528., 2313024., 2325408., 2343012., 2355432., 2373144.,
      2385600., 2364396., 2377320., 2395392., 2408352., 2426532., 2439528.,
      2457816., 2470848., 2384700., 2397768., 2415984., 2429088., 2447412.,
      2460552., 2478984., 2492160., 2405004., 2418216., 2436576., 2449824.,
      2468292., 2481576., 2500152., 2513472., 2425308., 2438664., 2457168.,
      2470560., 2489172., 2502600., 2521320., 2534784., 2445612., 2459112.,
      2477760., 2491296., 2510052., 2523624., 2542488., 2556096., 2526828.,
      2540904., 2560128., 2574240., 2593572., 2607720., 2627160., 2641344.,
      2547132., 2561352., 2580720., 2594976., 2614452., 2628744., 2648328.,
      2662656., 2567436., 2581800., 2601312., 2615712., 2635332., 2649768.,
      2669496., 2683968., 2587740., 2602248., 2621904., 2636448., 2656212.,
      2670792., 2690664., 2705280., 2608044., 2622696., 2642496., 2657184.,
      2677092., 2691816., 2711832., 2726592.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3771438.,  3789132.,  3806826.,  3824520.,  3865272.,  3883056.,
      3900840.,  3918624.,  3959826.,  3977700.,  3995574.,  4013448.,
      4055100.,  4073064.,  4091028.,  4108992.,  4293429.,  4314282.,
      4335135.,  4355988.,  4402902.,  4423860.,  4444818.,  4465776.,
      4513215.,  4534278.,  4555341.,  4576404.,  4624368.,  4645536.,
      4666704.,  4687872.,  4782408.,  4806480.,  4830552.,  4854624.,
      4907520.,  4931712.,  4955904.,  4980096.,  5033592.,  5057904.,
      5082216.,  5106528.,  5160624.,  5185056.,  5209488.,  5233920.,
      4055625.,  4076898.,  4098171.,  4119444.,  4165098.,  4186476.,
      4207854.,  4229232.,  4275411.,  4296894.,  4318377.,  4339860.,
      4386564.,  4408152.,  4429740.,  4451328.,  3363774.,  3382188.,
      3400602.,  3419016.,  3457608.,  3476112.,  3494616.,  3513120.,
      3552162.,  3570756.,  3589350.,  3607944.,  3647436.,  3666120.,
      3684804.,  3703488.,  5258436.,  5280168.,  5301900.,  5323632.,
      5372880.,  5394720.,  5416560.,  5438400.,  5488188.,  5510136.,
      5532084.,  5554032.,  5604360.,  5626416.,  5648472.,  5670528.,
      6001926.,  6027532.,  6053138.,  6078744.,  6135444.,  6161176.,
      6186908.,  6212640.,  6269970.,  6295828.,  6321686.,  6347544.,
      6405504.,  6431488.,  6457472.,  6483456.,  6704368.,  6733920.,
      6763472.,  6793024.,  6856960.,  6886656.,  6916352.,  6946048.,
      7010704.,  7040544.,  7070384.,  7100224.,  7165600.,  7195584.,
      7225568.,  7255552.,  5706526.,  5732636.,  5758746.,  5784856.,
      5840044.,  5866280.,  5892516.,  5918752.,  5974570.,  6000932.,
      6027294.,  6053656.,  6110104.,  6136592.,  6163080.,  6189568.,
      4752036.,  4774632.,  4797228.,  4819824.,  4866480.,  4889184.,
      4911888.,  4934592.,  4981788.,  5004600.,  5027412.,  5050224.,
      5097960.,  5120880.,  5143800.,  5166720.,  7459482.,  7485828.,
      7512174.,  7538520.,  7597608.,  7624080.,  7650552.,  7677024.,
      7736742.,  7763340.,  7789938.,  7816536.,  7876884.,  7903608.,
      7930332.,  7957056.,  8539895.,  8570926.,  8601957.,  8632988.,
      8701042.,  8732220.,  8763398.,  8794576.,  8863365.,  8894690.,
      8926015.,  8957340.,  9026864.,  9058336.,  9089808.,  9121280.,
      9570200.,  9606000.,  9641800.,  9677600.,  9754368.,  9790336.,
      9826304.,  9862272.,  9939880.,  9976016.,  10012152., 10048288.,
      10126736., 10163040., 10199344., 10235648., 8179731.,  8211350.,
      8242969.,  8274588.,  8340878.,  8372644.,  8404410.,  8436176.,
      8503201.,  8535114.,  8567027.,  8598940.,  8666700.,  8698760.,
      8730820.,  8762880.,  6842058.,  6869412.,  6896766.,  6924120.,
      6980184.,  7007664.,  7035144.,  7062624.,  7119318.,  7146924.,
      7174530.,  7202136.,  7259460.,  7287192.,  7314924.,  7342656.,
      5991492.,  6013608.,  6035724.,  6057840.,  6109008.,  6131232.,
      6153456.,  6175680.,  6227388.,  6249720.,  6272052.,  6294384.,
      6346632.,  6369072.,  6391512.,  6413952.,  6857158.,  6883212.,
      6909266.,  6935320.,  6994260.,  7020440.,  7046620.,  7072800.,
      7132370.,  7158676.,  7184982.,  7211288.,  7271488.,  7297920.,
      7324352.,  7350784.,  7681776.,  7711840.,  7741904.,  7771968.,
      7838464.,  7868672.,  7898880.,  7929088.,  7996304.,  8026656.,
      8057008.,  8087360.,  8155296.,  8185792.,  8216288.,  8246784.,
      6561758.,  6588316.,  6614874.,  6641432.,  6698860.,  6725544.,
      6752228.,  6778912.,  6836970.,  6863780.,  6890590.,  6917400.,
      6976088.,  7003024.,  7029960.,  7056896.,  5485092.,  5508072.,
      5531052.,  5554032.,  5602608.,  5625696.,  5648784.,  5671872.,
      5720988.,  5744184.,  5767380.,  5790576.,  5840232.,  5863536.,
      5886840.,  5910144.,  4939950.,  4957260.,  4974570.,  4991880.,
      5033784.,  5051184.,  5068584.,  5085984.,  5128338.,  5145828.,
      5163318.,  5180808.,  5223612.,  5241192.,  5258772.,  5276352.,
      5663861.,  5684266.,  5704671.,  5725076.,  5773334.,  5793844.,
      5814354.,  5834864.,  5883647.,  5904262.,  5924877.,  5945492.,
      5994800.,  6015520.,  6036240.,  6056960.,  6356808.,  6380368.,
      6403928.,  6427488.,  6481920.,  6505600.,  6529280.,  6552960.,
      6607992.,  6631792.,  6655592.,  6679392.,  6735024.,  6758944.,
      6782864.,  6806784.,  5440393.,  5461218.,  5482043.,  5502868.,
      5549866.,  5570796.,  5591726.,  5612656.,  5660179.,  5681214.,
      5702249.,  5723284.,  5771332.,  5792472.,  5813612.,  5834752.,
      4556862.,  4574892.,  4592922.,  4610952.,  4650696.,  4668816.,
      4686936.,  4705056.,  4745250.,  4763460.,  4781670.,  4799880.,
      4840524.,  4858824.,  4877124.,  4895424.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3744732., 3754200., 3763668., 3773136., 3792864., 3802368., 3811872.,
      3821376., 3841284., 3850824., 3860364., 3869904., 3889992., 3899568.,
      3909144., 3918720., 3785196., 3794808., 3804420., 3814032., 3833904.,
      3843552., 3853200., 3862848., 3882900., 3892584., 3902268., 3911952.,
      3932184., 3941904., 3951624., 3961344., 3825660., 3835416., 3845172.,
      3854928., 3874944., 3884736., 3894528., 3904320., 3924516., 3934344.,
      3944172., 3954000., 3974376., 3984240., 3994104., 4003968., 3866124.,
      3876024., 3885924., 3895824., 3915984., 3925920., 3935856., 3945792.,
      3966132., 3976104., 3986076., 3996048., 4016568., 4026576., 4036584.,
      4046592., 3906588., 3916632., 3926676., 3936720., 3957024., 3967104.,
      3977184., 3987264., 4007748., 4017864., 4027980., 4038096., 4058760.,
      4068912., 4079064., 4089216., 4068444., 4079064., 4089684., 4100304.,
      4121184., 4131840., 4142496., 4153152., 4174212., 4184904., 4195596.,
      4206288., 4227528., 4238256., 4248984., 4259712., 4108908., 4119672.,
      4130436., 4141200., 4162224., 4173024., 4183824., 4194624., 4215828.,
      4226664., 4237500., 4248336., 4269720., 4280592., 4291464., 4302336.,
      4149372., 4160280., 4171188., 4182096., 4203264., 4214208., 4225152.,
      4236096., 4257444., 4268424., 4279404., 4290384., 4311912., 4322928.,
      4333944., 4344960., 4189836., 4200888., 4211940., 4222992., 4244304.,
      4255392., 4266480., 4277568., 4299060., 4310184., 4321308., 4332432.,
      4354104., 4365264., 4376424., 4387584., 4230300., 4241496., 4252692.,
      4263888., 4285344., 4296576., 4307808., 4319040., 4340676., 4351944.,
      4363212., 4374480., 4396296., 4407600., 4418904., 4430208., 4392156.,
      4403928., 4415700., 4427472., 4449504., 4461312., 4473120., 4484928.,
      4507140., 4518984., 4530828., 4542672., 4565064., 4576944., 4588824.,
      4600704., 4432620., 4444536., 4456452., 4468368., 4490544., 4502496.,
      4514448., 4526400., 4548756., 4560744., 4572732., 4584720., 4607256.,
      4619280., 4631304., 4643328., 4473084., 4485144., 4497204., 4509264.,
      4531584., 4543680., 4555776., 4567872., 4590372., 4602504., 4614636.,
      4626768., 4649448., 4661616., 4673784., 4685952., 4513548., 4525752.,
      4537956., 4550160., 4572624., 4584864., 4597104., 4609344., 4631988.,
      4644264., 4656540., 4668816., 4691640., 4703952., 4716264., 4728576.,
      4554012., 4566360., 4578708., 4591056., 4613664., 4626048., 4638432.,
      4650816., 4673604., 4686024., 4698444., 4710864., 4733832., 4746288.,
      4758744., 4771200., 4715868., 4728792., 4741716., 4754640., 4777824.,
      4790784., 4803744., 4816704., 4840068., 4853064., 4866060., 4879056.,
      4902600., 4915632., 4928664., 4941696., 4756332., 4769400., 4782468.,
      4795536., 4818864., 4831968., 4845072., 4858176., 4881684., 4894824.,
      4907964., 4921104., 4944792., 4957968., 4971144., 4984320., 4796796.,
      4810008., 4823220., 4836432., 4859904., 4873152., 4886400., 4899648.,
      4923300., 4936584., 4949868., 4963152., 4986984., 5000304., 5013624.,
      5026944., 4837260., 4850616., 4863972., 4877328., 4900944., 4914336.,
      4927728., 4941120., 4964916., 4978344., 4991772., 5005200., 5029176.,
      5042640., 5056104., 5069568., 4877724., 4891224., 4904724., 4918224.,
      4941984., 4955520., 4969056., 4982592., 5006532., 5020104., 5033676.,
      5047248., 5071368., 5084976., 5098584., 5112192., 5039580., 5053656.,
      5067732., 5081808., 5106144., 5120256., 5134368., 5148480., 5172996.,
      5187144., 5201292., 5215440., 5240136., 5254320., 5268504., 5282688.,
      5080044., 5094264., 5108484., 5122704., 5147184., 5161440., 5175696.,
      5189952., 5214612., 5228904., 5243196., 5257488., 5282328., 5296656.,
      5310984., 5325312., 5120508., 5134872., 5149236., 5163600., 5188224.,
      5202624., 5217024., 5231424., 5256228., 5270664., 5285100., 5299536.,
      5324520., 5338992., 5353464., 5367936., 5160972., 5175480., 5189988.,
      5204496., 5229264., 5243808., 5258352., 5272896., 5297844., 5312424.,
      5327004., 5341584., 5366712., 5381328., 5395944., 5410560., 5201436.,
      5216088., 5230740., 5245392., 5270304., 5284992., 5299680., 5314368.,
      5339460., 5354184., 5368908., 5383632., 5408904., 5423664., 5438424.,
      5453184.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      493164., 617130., 741330., 618210., 494892., 581406.,  727230.,
      873201., 727860., 582414., 670224., 837960., 1005720., 837960.,
      670224., 582414., 727860., 873201., 727230., 581406.,  494892.,
      618210., 741330., 617130., 493164.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24060., 24360., 24660., 24960., 25260., 25860., 26160., 26460., 26760.,
      27060., 27660., 27960., 28260., 28560., 28860., 29460., 29760., 30060.,
      30360., 30660., 31260., 31560., 31860., 32160., 32460.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      981612.,  986328.,  1228320., 1234260., 1475478., 1482660., 1230390.,
      1236420., 984924.,  989784.,  1157058., 1162812., 1447215., 1454460.,
      1737645., 1746402., 1448370., 1455720., 1158906., 1164828., 1333584.,
      1340448., 1667280., 1675920., 2001000., 2011440., 1667160., 1675920.,
      1333392., 1340448., 1158570., 1164828., 1447845., 1455720., 1736889.,
      1746402., 1446480., 1454460., 1156386., 1162812., 984204.,  989784.,
      1229400., 1236420., 1474182., 1482660., 1227150., 1234260., 980604.,
      986328.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46716., 48120., 47292., 48720., 47868., 49320., 48444., 49920., 49020.,
      50520., 50172., 51720., 50748., 52320., 51324., 52920., 51900., 53520.,
      52476., 54120., 53628., 55320., 54204., 55920., 54780., 56520., 55356.,
      57120., 55932., 57720., 57084., 58920., 57660., 59520., 58236., 60120.,
      58812., 60720., 59388., 61320., 60540., 62520., 61116., 63120., 61692.,
      63720., 62268., 64320., 62844., 64920.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1958508., 1963224., 1967940., 1972656., 2450700., 2456640., 2462580.,
      2468520., 2943774., 2950956., 2958138., 2965320., 2454750., 2460780.,
      2466810., 2472840., 1964988., 1969848., 1974708., 1979568., 2308362.,
      2314116., 2319870., 2325624., 2887185., 2894430., 2901675., 2908920.,
      3466533., 3475290., 3484047., 3492804., 2889390., 2896740., 2904090.,
      2911440., 2311890., 2317812., 2323734., 2329656., 2660304., 2667168.,
      2674032., 2680896., 3325920., 3334560., 3343200., 3351840., 3991560.,
      4002000., 4012440., 4022880., 3325560., 3334320., 3343080., 3351840.,
      2659728., 2666784., 2673840., 2680896., 2310882., 2317140., 2323398.,
      2329656., 2887815., 2895690., 2903565., 2911440., 3464265., 3473778.,
      3483291., 3492804., 2884980., 2892960., 2900940., 2908920., 2306346.,
      2312772., 2319198., 2325624., 1962828., 1968408., 1973988., 1979568.,
      2451780., 2458800., 2465820., 2472840., 2939886., 2948364., 2956842.,
      2965320., 2447190., 2454300., 2461410., 2468520., 1955484., 1961208.,
      1966932., 1972656.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92028.,  93432.,  94836.,  96240.,  93156.,  94584.,  96012.,  97440.,
      94284.,  95736.,  97188.,  98640.,  95412.,  96888.,  98364.,  99840.,
      96540.,  98040.,  99540.,  101040., 98796.,  100344., 101892., 103440.,
      99924.,  101496., 103068., 104640., 101052., 102648., 104244., 105840.,
      102180., 103800., 105420., 107040., 103308., 104952., 106596., 108240.,
      105564., 107256., 108948., 110640., 106692., 108408., 110124., 111840.,
      107820., 109560., 111300., 113040., 108948., 110712., 112476., 114240.,
      110076., 111864., 113652., 115440., 112332., 114168., 116004., 117840.,
      113460., 115320., 117180., 119040., 114588., 116472., 118356., 120240.,
      115716., 117624., 119532., 121440., 116844., 118776., 120708., 122640.,
      119100., 121080., 123060., 125040., 120228., 122232., 124236., 126240.,
      121356., 123384., 125412., 127440., 122484., 124536., 126588., 128640.,
      123612., 125688., 127764., 129840.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1951848., 1972656., 2442510., 2468520., 2934108., 2965320., 2446830.,
      2472840., 1958760., 1979568., 2301348., 2325624., 2878575., 2908920.,
      3456390., 3492804., 2881095., 2911440., 2305380., 2329656., 2653152.,
      2680896., 3317160., 3351840., 3981264., 4022880., 3317160., 3351840.,
      2653152., 2680896., 2305380., 2329656., 2881095., 2911440., 3456390.,
      3492804., 2878575., 2908920., 2301348., 2325624., 1958760., 1979568.,
      2446830., 2472840., 2934108., 2965320., 2442510., 2468520., 1951848.,
      1972656.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92856.,  96240.,  94008.,  97440.,  95160.,  98640.,  96312.,  99840.,
      97464.,  101040., 99768.,  103440., 100920., 104640., 102072., 105840.,
      103224., 107040., 104376., 108240., 106680., 110640., 107832., 111840.,
      108984., 113040., 110136., 114240., 111288., 115440., 113592., 117840.,
      114744., 119040., 115896., 120240., 117048., 121440., 118200., 122640.,
      120504., 125040., 121656., 126240., 122808., 127440., 123960., 128640.,
      125112., 129840.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3894336., 3903696., 3935880., 3945312., 4873230., 4885020., 4925160.,
      4937040., 5853960., 5868216., 5916276., 5930640., 4881690., 4893660.,
      4933620., 4945680., 3907872., 3917520., 3949416., 3959136., 4591272.,
      4602696., 4639740., 4651248., 5742765., 5757150., 5803350., 5817840.,
      6895392., 6912780., 6968094., 6985608., 5747595., 5762190., 5808180.,
      5822880., 4599000., 4610760., 4647468., 4659312., 5292672., 5306304.,
      5348064., 5361792., 6617160., 6634320., 6686400., 6703680., 7941792.,
      7962528., 8024880., 8045760., 6616920., 6634320., 6686160., 6703680.,
      5292288., 5306304., 5347680., 5361792., 4598328., 4610760., 4646796.,
      4659312., 5746545., 5762190., 5807130., 5822880., 6893880., 6912780.,
      6966582., 6985608., 5741295., 5757150., 5801880., 5817840., 4589928.,
      4602696., 4638396., 4651248., 3906432., 3917520., 3947976., 3959136.,
      4879710., 4893660., 4931640., 4945680., 5851368., 5868216., 5913684.,
      5930640., 4870890., 4885020., 4922820., 4937040., 3892320., 3903696.,
      3933864., 3945312.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      182928., 185712., 189672., 192480., 185184., 188016., 192024., 194880.,
      187440., 190320., 194376., 197280., 189696., 192624., 196728., 199680.,
      191952., 194928., 199080., 202080., 196464., 199536., 203784., 206880.,
      198720., 201840., 206136., 209280., 200976., 204144., 208488., 211680.,
      203232., 206448., 210840., 214080., 205488., 208752., 213192., 216480.,
      210000., 213360., 217896., 221280., 212256., 215664., 220248., 223680.,
      214512., 217968., 222600., 226080., 216768., 220272., 224952., 228480.,
      219024., 222576., 227304., 230880., 223536., 227184., 232008., 235680.,
      225792., 229488., 234360., 238080., 228048., 231792., 236712., 240480.,
      230304., 234096., 239064., 242880., 232560., 236400., 241416., 245280.,
      237072., 241008., 246120., 250080., 239328., 243312., 248472., 252480.,
      241584., 245616., 250824., 254880., 243840., 247920., 253176., 257280.,
      246096., 250224., 255528., 259680.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7779312.,  7788672.,  7798032.,  7807392.,  7862328.,  7871760.,
      7881192.,  7890624.,  9734670.,  9746460.,  9758250.,  9770040.,
      9838440.,  9850320.,  9862200.,  9874080.,  11693664., 11707920.,
      11722176., 11736432., 11818188., 11832552., 11846916., 11861280.,
      9751410.,  9763380.,  9775350.,  9787320.,  9855180.,  9867240.,
      9879300.,  9891360.,  7806096.,  7815744.,  7825392.,  7835040.,
      7889112.,  7898832.,  7908552.,  7918272.,  9171120.,  9182544.,
      9193968.,  9205392.,  9267972.,  9279480.,  9290988.,  9302496.,
      11471145., 11485530., 11499915., 11514300., 11592210., 11606700.,
      11621190., 11635680., 13773396., 13790784., 13808172., 13825560.,
      13918674., 13936188., 13953702., 13971216., 11480595., 11495190.,
      11509785., 11524380., 11601660., 11616360., 11631060., 11645760.,
      9186240.,  9198000.,  9209760.,  9221520.,  9283092.,  9294936.,
      9306780.,  9318624.,  10571712., 10585344., 10598976., 10612608.,
      10682400., 10696128., 10709856., 10723584., 13217160., 13234320.,
      13251480., 13268640., 13355520., 13372800., 13390080., 13407360.,
      15862848., 15883584., 15904320., 15925056., 16028880., 16049760.,
      16070640., 16091520., 13216440., 13233840., 13251240., 13268640.,
      13354800., 13372320., 13389840., 13407360., 10570560., 10584576.,
      10598592., 10612608., 10681248., 10695360., 10709472., 10723584.,
      9184224.,  9196656.,  9209088.,  9221520.,  9281076.,  9293592.,
      9306108.,  9318624.,  11477445., 11493090., 11508735., 11524380.,
      11598510., 11614260., 11630010., 11645760., 13768860., 13787760.,
      13806660., 13825560., 13914138., 13933164., 13952190., 13971216.,
      11466735., 11482590., 11498445., 11514300., 11587800., 11603760.,
      11619720., 11635680., 9167088.,  9179856.,  9192624.,  9205392.,
      9263940.,  9276792.,  9289644.,  9302496.,  7801776.,  7812864.,
      7823952.,  7835040.,  7884792.,  7895952.,  7907112.,  7918272.,
      9745470.,  9759420.,  9773370.,  9787320.,  9849240.,  9863280.,
      9877320.,  9891360.,  11685888., 11702736., 11719584., 11736432.,
      11810412., 11827368., 11844324., 11861280., 9727650.,  9741780.,
      9755910.,  9770040.,  9831420.,  9845640.,  9859860.,  9874080.,
      7773264.,  7784640.,  7796016.,  7807392.,  7856280.,  7867728.,
      7879176.,  7890624.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      363072., 365856., 368640., 371424., 376536., 379344., 382152., 384960.,
      367536., 370368., 373200., 376032., 381192., 384048., 386904., 389760.,
      372000., 374880., 377760., 380640., 385848., 388752., 391656., 394560.,
      376464., 379392., 382320., 385248., 390504., 393456., 396408., 399360.,
      380928., 383904., 386880., 389856., 395160., 398160., 401160., 404160.,
      389856., 392928., 396000., 399072., 404472., 407568., 410664., 413760.,
      394320., 397440., 400560., 403680., 409128., 412272., 415416., 418560.,
      398784., 401952., 405120., 408288., 413784., 416976., 420168., 423360.,
      403248., 406464., 409680., 412896., 418440., 421680., 424920., 428160.,
      407712., 410976., 414240., 417504., 423096., 426384., 429672., 432960.,
      416640., 420000., 423360., 426720., 432408., 435792., 439176., 442560.,
      421104., 424512., 427920., 431328., 437064., 440496., 443928., 447360.,
      425568., 429024., 432480., 435936., 441720., 445200., 448680., 452160.,
      430032., 433536., 437040., 440544., 446376., 449904., 453432., 456960.,
      434496., 438048., 441600., 445152., 451032., 454608., 458184., 461760.,
      443424., 447072., 450720., 454368., 460344., 464016., 467688., 471360.,
      447888., 451584., 455280., 458976., 465000., 468720., 472440., 476160.,
      452352., 456096., 459840., 463584., 469656., 473424., 477192., 480960.,
      456816., 460608., 464400., 468192., 474312., 478128., 481944., 485760.,
      461280., 465120., 468960., 472800., 478968., 482832., 486696., 490560.,
      470208., 474144., 478080., 482016., 488280., 492240., 496200., 500160.,
      474672., 478656., 482640., 486624., 492936., 496944., 500952., 504960.,
      479136., 483168., 487200., 491232., 497592., 501648., 505704., 509760.,
      483600., 487680., 491760., 495840., 502248., 506352., 510456., 514560.,
      488064., 492192., 496320., 500448., 506904., 511056., 515208., 519360.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7765992.,  7807392.,  7848936.,  7890624.,  9718290.,  9770040.,
      9821970.,  9874080.,  11674332., 11736432., 11798748., 11861280.,
      9735570.,  9787320.,  9839250.,  9891360.,  7793640.,  7835040.,
      7876584.,  7918272.,  9157092.,  9205392.,  9253860.,  9302496.,
      11453925., 11514300., 11574885., 11635680., 13753110., 13825560.,
      13898262., 13971216., 11464005., 11524380., 11584965., 11645760.,
      9173220.,  9221520.,  9269988.,  9318624.,  10557408., 10612608.,
      10668000., 10723584., 13199640., 13268640., 13337880., 13407360.,
      15842256., 15925056., 16008144., 16091520., 13199640., 13268640.,
      13337880., 13407360., 10557408., 10612608., 10668000., 10723584.,
      9173220.,  9221520.,  9269988.,  9318624.,  11464005., 11524380.,
      11584965., 11645760., 13753110., 13825560., 13898262., 13971216.,
      11453925., 11514300., 11574885., 11635680., 9157092.,  9205392.,
      9253860.,  9302496.,  7793640.,  7835040.,  7876584.,  7918272.,
      9735570.,  9787320.,  9839250.,  9891360.,  11674332., 11736432.,
      11798748., 11861280., 9718290.,  9770040.,  9821970.,  9874080.,
      7765992.,  7807392.,  7848936.,  7890624.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      364728., 371424., 378168., 384960., 369240., 376032., 382872., 389760.,
      373752., 380640., 387576., 394560., 378264., 385248., 392280., 399360.,
      382776., 389856., 396984., 404160., 391800., 399072., 406392., 413760.,
      396312., 403680., 411096., 418560., 400824., 408288., 415800., 423360.,
      405336., 412896., 420504., 428160., 409848., 417504., 425208., 432960.,
      418872., 426720., 434616., 442560., 423384., 431328., 439320., 447360.,
      427896., 435936., 444024., 452160., 432408., 440544., 448728., 456960.,
      436920., 445152., 453432., 461760., 445944., 454368., 462840., 471360.,
      450456., 458976., 467544., 476160., 454968., 463584., 472248., 480960.,
      459480., 468192., 476952., 485760., 463992., 472800., 481656., 490560.,
      473016., 482016., 491064., 500160., 477528., 486624., 495768., 504960.,
      482040., 491232., 500472., 509760., 486552., 495840., 505176., 514560.,
      491064., 500448., 509880., 519360.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3876600., 3894224., 3927584., 3945280., 3978856., 3996624.,  4030416.,
      4048256., 5053538., 5075492., 5117524., 5139568., 5181870.,  5204004.,
      5246576., 5268800., 6215364., 6241720., 6292352., 6318816.,  6369772.,
      6396344., 6447624., 6474304., 5254138., 5275940., 5318124.,  5340016.,
      5382470., 5404452., 5447176., 5469248., 4317368., 4334544.,  4368352.,
      4385600., 4419624., 4436944., 4471184., 4488576., 4967132.,  4986824.,
      5025760., 5045536., 5084724., 5104584., 5144024., 5163968.,  6446033.,
      6470602., 6519574., 6544248., 6593535., 6618314., 6667916.,  6692800.,
      7909074., 7938604., 7997528., 8027184., 8086486., 8116268.,  8175948.,
      8205856., 6691565., 6716042., 6765106., 6789688., 6839067.,  6863754.,
      6913448., 6938240., 5499452., 5518792., 5558080., 5577504.,  5617044.,
      5636552., 5676344., 5695936., 6124960., 6147008., 6191232.,  6213376.,
      6257888., 6280128., 6324928., 6347264., 7919768., 7947312.,  8002864.,
      8030528., 8086440., 8114224., 8170496., 8198400., 9696816.,  9729952.,
      9796736., 9830016., 9897232., 9930656., 9998304., 10031872., 7942328.,
      7969840., 8025424., 8053056., 8109000., 8136752., 8193056.,  8220928.,
      6215328., 6237120., 6281600., 6303488., 6348256., 6370240.,  6415296.,
      6437376., 5458172., 5477832., 5516800., 5536544., 5575764.,  5595592.,
      5635064., 5654976., 6728377., 6752906., 6801918., 6826552.,  6875879.,
      6900618., 6950260., 6975104., 7982850., 8012332., 8071304.,  8100912.,
      8160262., 8189996., 8249724., 8279584., 6548565., 6573002.,  6622106.,
      6646648., 6696067., 6720714., 6770448., 6795200., 5139548.,  5158856.,
      5198176., 5217568., 5257140., 5276616., 5316440., 5336000.,  4424056.,
      4441040., 4475040., 4492096., 4526312., 4543440., 4577872.,  4595072.,
      5473922., 5495076., 5537908., 5559152., 5602254., 5623588.,  5666960.,
      5688384., 6511236., 6536632., 6588224., 6613728., 6665644.,  6691256.,
      6743496., 6769216., 5359642., 5380644., 5423628., 5444720.,  5487974.,
      5509156., 5552680., 5573952., 4229944., 4246480., 4280928.,  4297536.,
      4332200., 4348880., 4383760., 4400512.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      723912.,  729456.,  737280.,  742848., 750744., 756336., 764304.,
      769920.,  732840.,  738480.,  746400., 752064., 760056., 765744.,
      773808.,  779520.,  741768.,  747504., 755520., 761280., 769368.,
      775152.,  783312.,  789120.,  750696., 756528., 764640., 770496.,
      778680.,  784560.,  792816.,  798720., 759624., 765552., 773760.,
      779712.,  787992.,  793968.,  802320., 808320., 777480., 783600.,
      792000.,  798144.,  806616.,  812784., 821328., 827520., 786408.,
      792624.,  801120.,  807360.,  815928., 822192., 830832., 837120.,
      795336.,  801648.,  810240.,  816576., 825240., 831600., 840336.,
      846720.,  804264.,  810672.,  819360., 825792., 834552., 841008.,
      849840.,  856320.,  813192.,  819696., 828480., 835008., 843864.,
      850416.,  859344.,  865920.,  831048., 837744., 846720., 853440.,
      862488.,  869232.,  878352.,  885120., 839976., 846768., 855840.,
      862656.,  871800.,  878640.,  887856., 894720., 848904., 855792.,
      864960.,  871872.,  881112.,  888048., 897360., 904320., 857832.,
      864816.,  874080.,  881088.,  890424., 897456., 906864., 913920.,
      866760.,  873840.,  883200.,  890304., 899736., 906864., 916368.,
      923520.,  884616.,  891888.,  901440., 908736., 918360., 925680.,
      935376.,  942720.,  893544.,  900912., 910560., 917952., 927672.,
      935088.,  944880.,  952320.,  902472., 909936., 919680., 927168.,
      936984.,  944496.,  954384.,  961920., 911400., 918960., 928800.,
      936384.,  946296.,  953904.,  963888., 971520., 920328., 927984.,
      937920.,  945600.,  955608.,  963312., 973392., 981120., 938184.,
      946032.,  956160.,  964032.,  974232., 982128., 992400., 1000320.,
      947112.,  955056.,  965280.,  973248., 983544., 991536., 1001904.,
      1009920., 956040.,  964080.,  974400., 982464., 992856., 1000944.,
      1011408., 1019520., 964968.,  973104., 983520., 991680., 1002168.,
      1010352., 1020912., 1029120., 973896., 982128., 992640., 1000896.,
      1011480., 1019760., 1030416., 1038720.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4353304., 4370928., 4388552., 4406176., 4441888., 4459584., 4477280.,
      4494976., 4531048., 4548816., 4566584., 4584352., 4620784., 4638624.,
      4656464., 4674304., 5576962., 5598916., 5620870., 5642824., 5687948.,
      5709992., 5732036., 5754080., 5799654., 5821788., 5843922., 5866056.,
      5912080., 5934304., 5956528., 5978752., 6755988., 6782344., 6808700.,
      6835056., 6889376., 6915840., 6942304., 6968768., 7023628., 7050200.,
      7076772., 7103344., 7158744., 7185424., 7212104., 7238784., 5607114.,
      5628916., 5650718., 5672520., 5717588., 5739480., 5761372., 5783264.,
      5828782., 5850764., 5872746., 5894728., 5940696., 5962768., 5984840.,
      6006912., 4519512., 4536688., 4553864., 4571040., 4607072., 4624320.,
      4641568., 4658816., 4695208., 4712528., 4729848., 4747168., 4783920.,
      4801312., 4818704., 4836096., 5004492., 5024184., 5043876., 5063568.,
      5104256., 5124032., 5143808., 5163584., 5204692., 5224552., 5244412.,
      5264272., 5305800., 5325744., 5345688., 5365632., 6433193., 6457762.,
      6482331., 6506900., 6558154., 6582828., 6607502., 6632176., 6683955.,
      6708734., 6733513., 6758292., 6810596., 6835480., 6860364., 6885248.,
      7811658., 7841188., 7870718., 7900248., 7961816., 7991472., 8021128.,
      8050784., 8112982., 8142764., 8172546., 8202328., 8265156., 8295064.,
      8324972., 8354880., 6520381., 6544858., 6569335., 6593812., 6644830.,
      6669412., 6693994., 6718576., 6770119., 6794806., 6819493., 6844180.,
      6896248., 6921040., 6945832., 6970624., 5296364., 5315704., 5335044.,
      5354384., 5395104., 5414528., 5433952., 5453376., 5494516., 5514024.,
      5533532., 5553040., 5594600., 5614192., 5633784., 5653376., 5691680.,
      5713728., 5735776., 5757824., 5802624., 5824768., 5846912., 5869056.,
      5914336., 5936576., 5958816., 5981056., 6026816., 6049152., 6071488.,
      6093824., 7328664., 7356208., 7383752., 7411296., 7467600., 7495264.,
      7522928., 7550592., 7607496., 7635280., 7663064., 7690848., 7748352.,
      7776256., 7804160., 7832064., 8907504., 8940640., 8973776., 9006912.,
      9074432., 9107712., 9140992., 9174272., 9242512., 9275936., 9309360.,
      9342784., 9411744., 9445312., 9478880., 9512448., 7199224., 7226736.,
      7254248., 7281760., 7337648., 7365280., 7392912., 7420544., 7477032.,
      7504784., 7532536., 7560288., 7617376., 7645248., 7673120., 7700992.,
      5566496., 5588288., 5610080., 5631872., 5676416., 5698304., 5720192.,
      5742080., 5787104., 5809088., 5831072., 5853056., 5898560., 5920640.,
      5942720., 5964800., 4776236., 4795896., 4815556., 4835216., 4873952.,
      4893696., 4913440., 4933184., 4972340., 4992168., 5011996., 5031824.,
      5071400., 5091312., 5111224., 5131136., 5860769., 5885298., 5909827.,
      5934356., 5983170., 6007804., 6032438., 6057072., 6106411., 6131150.,
      6155889., 6180628., 6230492., 6255336., 6280180., 6305024., 6893274.,
      6922756., 6952238., 6981720., 7040360., 7069968., 7099576., 7129184.,
      7188454., 7218188., 7247922., 7277656., 7337556., 7367416., 7397276.,
      7427136., 5586741., 5611178., 5635615., 5660052., 5708630., 5733172.,
      5757714., 5782256., 5831359., 5856006., 5880653., 5905300., 5954928.,
      5979680., 6004432., 6029184., 4349260., 4368568., 4387876., 4407184.,
      4445952., 4465344., 4484736., 4504128., 4543316., 4562792., 4582268.,
      4601744., 4641352., 4660912., 4680472., 4700032., 3699864., 3716848.,
      3733832., 3750816., 3784352., 3801408., 3818464., 3835520., 3869416.,
      3886544., 3903672., 3920800., 3955056., 3972256., 3989456., 4006656.,
      4590690., 4611844., 4632998., 4654152., 4696556., 4717800., 4739044.,
      4760288., 4803142., 4824476., 4845810., 4867144., 4910448., 4931872.,
      4953296., 4974720., 5437908., 5463304., 5488700., 5514096., 5565152.,
      5590656., 5616160., 5641664., 5693260., 5718872., 5744484., 5770096.,
      5822232., 5847952., 5873672., 5899392., 4445738., 4466740., 4487742.,
      4508744., 4551092., 4572184., 4593276., 4614368., 4657166., 4678348.,
      4699530., 4720712., 4763960., 4785232., 4806504., 4827776., 3513816.,
      3530352., 3546888., 3563424., 3597280., 3613888., 3630496., 3647104.,
      3681320., 3698000., 3714680., 3731360., 3765936., 3782688., 3799440.,
      3816192.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1442280., 1447824., 1453368., 1458912., 1468992., 1474560., 1480128.,
      1485696., 1495896., 1501488., 1507080., 1512672., 1522992., 1528608.,
      1534224., 1539840., 1460040., 1465680., 1471320., 1476960., 1487136.,
      1492800., 1498464., 1504128., 1514424., 1520112., 1525800., 1531488.,
      1541904., 1547616., 1553328., 1559040., 1477800., 1483536., 1489272.,
      1495008., 1505280., 1511040., 1516800., 1522560., 1532952., 1538736.,
      1544520., 1550304., 1560816., 1566624., 1572432., 1578240., 1495560.,
      1501392., 1507224., 1513056., 1523424., 1529280., 1535136., 1540992.,
      1551480., 1557360., 1563240., 1569120., 1579728., 1585632., 1591536.,
      1597440., 1513320., 1519248., 1525176., 1531104., 1541568., 1547520.,
      1553472., 1559424., 1570008., 1575984., 1581960., 1587936., 1598640.,
      1604640., 1610640., 1616640., 1548840., 1554960., 1561080., 1567200.,
      1577856., 1584000., 1590144., 1596288., 1607064., 1613232., 1619400.,
      1625568., 1636464., 1642656., 1648848., 1655040., 1566600., 1572816.,
      1579032., 1585248., 1596000., 1602240., 1608480., 1614720., 1625592.,
      1631856., 1638120., 1644384., 1655376., 1661664., 1667952., 1674240.,
      1584360., 1590672., 1596984., 1603296., 1614144., 1620480., 1626816.,
      1633152., 1644120., 1650480., 1656840., 1663200., 1674288., 1680672.,
      1687056., 1693440., 1602120., 1608528., 1614936., 1621344., 1632288.,
      1638720., 1645152., 1651584., 1662648., 1669104., 1675560., 1682016.,
      1693200., 1699680., 1706160., 1712640., 1619880., 1626384., 1632888.,
      1639392., 1650432., 1656960., 1663488., 1670016., 1681176., 1687728.,
      1694280., 1700832., 1712112., 1718688., 1725264., 1731840., 1655400.,
      1662096., 1668792., 1675488., 1686720., 1693440., 1700160., 1706880.,
      1718232., 1724976., 1731720., 1738464., 1749936., 1756704., 1763472.,
      1770240., 1673160., 1679952., 1686744., 1693536., 1704864., 1711680.,
      1718496., 1725312., 1736760., 1743600., 1750440., 1757280., 1768848.,
      1775712., 1782576., 1789440., 1690920., 1697808., 1704696., 1711584.,
      1723008., 1729920., 1736832., 1743744., 1755288., 1762224., 1769160.,
      1776096., 1787760., 1794720., 1801680., 1808640., 1708680., 1715664.,
      1722648., 1729632., 1741152., 1748160., 1755168., 1762176., 1773816.,
      1780848., 1787880., 1794912., 1806672., 1813728., 1820784., 1827840.,
      1726440., 1733520., 1740600., 1747680., 1759296., 1766400., 1773504.,
      1780608., 1792344., 1799472., 1806600., 1813728., 1825584., 1832736.,
      1839888., 1847040., 1761960., 1769232., 1776504., 1783776., 1795584.,
      1802880., 1810176., 1817472., 1829400., 1836720., 1844040., 1851360.,
      1863408., 1870752., 1878096., 1885440., 1779720., 1787088., 1794456.,
      1801824., 1813728., 1821120., 1828512., 1835904., 1847928., 1855344.,
      1862760., 1870176., 1882320., 1889760., 1897200., 1904640., 1797480.,
      1804944., 1812408., 1819872., 1831872., 1839360., 1846848., 1854336.,
      1866456., 1873968., 1881480., 1888992., 1901232., 1908768., 1916304.,
      1923840., 1815240., 1822800., 1830360., 1837920., 1850016., 1857600.,
      1865184., 1872768., 1884984., 1892592., 1900200., 1907808., 1920144.,
      1927776., 1935408., 1943040., 1833000., 1840656., 1848312., 1855968.,
      1868160., 1875840., 1883520., 1891200., 1903512., 1911216., 1918920.,
      1926624., 1939056., 1946784., 1954512., 1962240., 1868520., 1876368.,
      1884216., 1892064., 1904448., 1912320., 1920192., 1928064., 1940568.,
      1948464., 1956360., 1964256., 1976880., 1984800., 1992720., 2000640.,
      1886280., 1894224., 1902168., 1910112., 1922592., 1930560., 1938528.,
      1946496., 1959096., 1967088., 1975080., 1983072., 1995792., 2003808.,
      2011824., 2019840., 1904040., 1912080., 1920120., 1928160., 1940736.,
      1948800., 1956864., 1964928., 1977624., 1985712., 1993800., 2001888.,
      2014704., 2022816., 2030928., 2039040., 1921800., 1929936., 1938072.,
      1946208., 1958880., 1967040., 1975200., 1983360., 1996152., 2004336.,
      2012520., 2020704., 2033616., 2041824., 2050032., 2058240., 1939560.,
      1947792., 1956024., 1964256., 1977024., 1985280., 1993536., 2001792.,
      2014680., 2022960., 2031240., 2039520., 2052528., 2060832., 2069136.,
      2077440.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      838065.,  1006614., 1175433., 1008126., 840585.,  987910.,  1186143.,
      1384544., 1187025., 989380.,  1138700., 1366680., 1594684., 1366680.,
      1138700., 989380.,  1187025., 1384544., 1186143., 987910.,  840585.,
      1008126., 1175433., 1006614., 838065.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      62718., 63384., 64050., 64716., 65382., 67380., 68046., 68712., 69378.,
      70044., 72042., 72708., 73374., 74040., 74706., 76704., 77370., 78036.,
      78702., 79368., 81366., 82032., 82698., 83364., 84030.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1669245., 1676130., 2004912., 2013228., 2341101., 2350866., 2007828.,
      2016252., 1674105., 1681170., 1967420., 1975820., 2362143., 2372286.,
      2757181., 2769088., 2363781., 2374050., 1970150., 1978760., 2267380.,
      2277400., 2721264., 2733360., 3175172., 3189368., 2721120., 2733360.,
      2267140., 2277400., 1969625., 1978760., 2363025., 2374050., 2756152.,
      2769088., 2361135., 2372286., 1966475., 1975820., 1673025., 1681170.,
      2006424., 2016252., 2339337., 2350866., 2003292., 2013228., 1667805.,
      1676130.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      122970., 125436., 124266., 126768., 125562., 128100., 126858., 129432.,
      128154., 130764., 132042., 134760., 133338., 136092., 134634., 137424.,
      135930., 138756., 137226., 140088., 141114., 144084., 142410., 145416.,
      143706., 146748., 145002., 148080., 146298., 149412., 150186., 153408.,
      151482., 154740., 152778., 156072., 154074., 157404., 155370., 158736.,
      159258., 162732., 160554., 164064., 161850., 165396., 163146., 166728.,
      164442., 168060.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3331605., 3338490., 3345375., 3352260., 4001508., 4009824., 4018140.,
      4026456., 4672437., 4682202., 4691967., 4701732., 4007232., 4015656.,
      4024080., 4032504., 3341145., 3348210., 3355275., 3362340., 3926440.,
      3934840., 3943240., 3951640., 4714143., 4724286., 4734429., 4744572.,
      5502455., 5514362., 5526269., 5538176., 4717293., 4727562., 4737831.,
      4748100., 3931690., 3940300., 3948910., 3957520., 4524740., 4534760.,
      4544780., 4554800., 5430432., 5442528., 5454624., 5466720., 6336148.,
      6350344., 6364540., 6378736., 5430000., 5442240., 5454480., 5466720.,
      4524020., 4534280., 4544540., 4554800., 3930115., 3939250., 3948385.,
      3957520., 4715025., 4726050., 4737075., 4748100., 5499368., 5512304.,
      5525240., 5538176., 4711119., 4722270., 4733421., 4744572., 3923605.,
      3932950., 3942295., 3951640., 3337905., 3346050., 3354195., 3362340.,
      4003020., 4012848., 4022676., 4032504., 4667145., 4678674., 4690203.,
      4701732., 3996648., 4006584., 4016520., 4026456., 3327285., 3335610.,
      3343935., 3352260.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      243474., 245940., 248406., 250872., 246030., 248532., 251034., 253536.,
      248586., 251124., 253662., 256200., 251142., 253716., 256290., 258864.,
      253698., 256308., 258918., 261528., 261366., 264084., 266802., 269520.,
      263922., 266676., 269430., 272184., 266478., 269268., 272058., 274848.,
      269034., 271860., 274686., 277512., 271590., 274452., 277314., 280176.,
      279258., 282228., 285198., 288168., 281814., 284820., 287826., 290832.,
      284370., 287412., 290454., 293496., 286926., 290004., 293082., 296160.,
      289482., 292596., 295710., 298824., 297150., 300372., 303594., 306816.,
      299706., 302964., 306222., 309480., 302262., 305556., 308850., 312144.,
      304818., 308148., 311478., 314808., 307374., 310740., 314106., 317472.,
      315042., 318516., 321990., 325464., 317598., 321108., 324618., 328128.,
      320154., 323700., 327246., 330792., 322710., 326292., 329874., 333456.,
      325266., 328884., 332502., 336120.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3321930., 3352260., 3990060., 4026456., 4659270., 4701732., 3996108.,
      4032504., 3332010., 3362340., 3916255., 3951640., 4702110., 4744572.,
      5488637., 5538176., 4705638., 4748100., 3922135., 3957520., 4514360.,
      4554800., 5418192., 5466720., 6322120., 6378736., 5418192., 5466720.,
      4514360., 4554800., 3922135., 3957520., 4705638., 4748100., 5488637.,
      5538176., 4702110., 4744572., 3916255., 3951640., 3332010., 3362340.,
      3996108., 4032504., 4659270., 4701732., 3990060., 4026456., 3321930.,
      3352260.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      244644., 250872., 247236., 253536., 249828., 256200., 252420., 258864.,
      255012., 261528., 262788., 269520., 265380., 272184., 267972., 274848.,
      270564., 277512., 273156., 280176., 280932., 288168., 283524., 290832.,
      286116., 293496., 288708., 296160., 291300., 298824., 299076., 306816.,
      301668., 309480., 304260., 312144., 306852., 314808., 309444., 317472.,
      317220., 325464., 319812., 328128., 322404., 330792., 324996., 333456.,
      327588., 336120.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6630180.,  6643860.,  6690750.,  6704520.,  7963596.,  7980120.,
      8036280.,  8052912.,  9299136.,  9318540.,  9383934.,  9403464.,
      7975476.,  7992216.,  8048160.,  8065008.,  6649980.,  6664020.,
      6710550.,  6724680.,  7815815.,  7832510.,  7886480.,  7903280.,
      9384060.,  9404220.,  9468858.,  9489144.,  10953607., 10977274.,
      11052538., 11076352., 9390864.,  9411276.,  9475662.,  9496200.,
      7827155.,  7844270.,  7897820.,  7915040.,  9008800.,  9028720.,
      9089560.,  9109600.,  10812336., 10836384., 10909248., 10933440.,
      12616016., 12644240., 12729080., 12757472., 10812048., 10836384.,
      10908960., 10933440., 9008320.,  9028720.,  9089080.,  9109600.,
      7826105.,  7844270.,  7896770.,  7915040.,  9389352.,  9411276.,
      9474150.,  9496200.,  10951549., 10977274., 11050480., 11076352.,
      9382044.,  9404220.,  9466842.,  9489144.,  7813925.,  7832510.,
      7884590.,  7903280.,  6647820.,  6664020.,  6708390.,  6724680.,
      7972668.,  7992216.,  8045352.,  8065008.,  9295608.,  9318540.,
      9380406.,  9403464.,  7960356.,  7980120.,  8033040.,  8052912.,
      6627300.,  6643860.,  6687870.,  6704520.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      484392., 489288., 496812., 501744., 489504., 494472., 502068., 507072.,
      494616., 499656., 507324., 512400., 499728., 504840., 512580., 517728.,
      504840., 510024., 517836., 523056., 520176., 525576., 533604., 539040.,
      525288., 530760., 538860., 544368., 530400., 535944., 544116., 549696.,
      535512., 541128., 549372., 555024., 540624., 546312., 554628., 560352.,
      555960., 561864., 570396., 576336., 561072., 567048., 575652., 581664.,
      566184., 572232., 580908., 586992., 571296., 577416., 586164., 592320.,
      576408., 582600., 591420., 597648., 591744., 598152., 607188., 613632.,
      596856., 603336., 612444., 618960., 601968., 608520., 617700., 624288.,
      607080., 613704., 622956., 629616., 612192., 618888., 628212., 634944.,
      627528., 634440., 643980., 650928., 632640., 639624., 649236., 656256.,
      637752., 644808., 654492., 661584., 642864., 649992., 659748., 666912.,
      647976., 655176., 665004., 672240.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5136600.,  5150280.,  5163960.,  5177640.,  5226930.,  5240700.,
      5254470.,  5268240.,  6372108.,  6388632.,  6405156.,  6421680.,
      6481528.,  6498160.,  6514792.,  6531424.,  7601588.,  7620992.,
      7640396.,  7659800.,  7730098.,  7749628.,  7769158.,  7788688.,
      6558468.,  6575208.,  6591948.,  6608688.,  6668912.,  6685760.,
      6702608.,  6719456.,  5524000.,  5538040.,  5552080.,  5566120.,
      5616378.,  5630508.,  5644638.,  5658768.,  7074775.,  7091470.,
      7108165.,  7124860.,  7185280.,  7202080.,  7218880.,  7235680.,
      8707640.,  8727800.,  8747960.,  8768120.,  8841270.,  8861556.,
      8881842.,  8902128.,  10332827., 10356494., 10380161., 10403828.,
      10489582., 10513396., 10537210., 10561024., 8898148.,  8918560.,
      8938972.,  8959384.,  9032802.,  9053340.,  9073878.,  9094416.,
      7473867.,  7490982.,  7508097.,  7525212.,  7586420.,  7603640.,
      7620860.,  7638080.,  9027440.,  9047360.,  9067280.,  9087200.,
      9158120.,  9178160.,  9198200.,  9218240.,  11058544., 11082592.,
      11106640., 11130688., 11216384., 11240576., 11264768., 11288960.,
      13079648., 13107872., 13136096., 13164320., 13264648., 13293040.,
      13321432., 13349824., 11249168., 11273504., 11297840., 11322176.,
      11408032., 11432512., 11456992., 11481472., 9431504.,  9451904.,
      9472304.,  9492704.,  9564232.,  9584752.,  9605272.,  9625792.,
      7979645.,  7997810.,  8015975.,  8034140.,  8095270.,  8113540.,
      8131810.,  8150080.,  9814188.,  9836112.,  9858036.,  9879960.,
      9953962.,  9976012.,  9998062.,  10020112., 11638397., 11664122.,
      11689847., 11715572., 11802320., 11828192., 11854064., 11879936.,
      10017432., 10039608., 10061784., 10083960., 10158230., 10180532.,
      10202834., 10225136., 8409521.,  8428106.,  8446691.,  8465276.,
      8527194.,  8545884.,  8564574.,  8583264.,  7012560.,  7028760.,
      7044960.,  7061160.,  7113130.,  7129420.,  7145710.,  7162000.,
      8668700.,  8688248.,  8707796.,  8727344.,  8790408.,  8810064.,
      8829720.,  8849376.,  10314844., 10337776., 10360708., 10383640.,
      10457690., 10480748., 10503806., 10526864., 8888596.,  8908360.,
      8928124.,  8947888.,  9011328.,  9031200.,  9051072.,  9070944.,
      7474968.,  7491528.,  7508088.,  7524648.,  7577586.,  7594236.,
      7610886.,  7627536.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      963888.,  968784.,  973680.,  978576.,  988692.,  993624.,  998556.,
      1003488., 974040.,  979008.,  983976.,  988944.,  999132.,  1004136.,
      1009140., 1014144., 984192.,  989232.,  994272.,  999312.,  1009572.,
      1014648., 1019724., 1024800., 994344.,  999456.,  1004568., 1009680.,
      1020012., 1025160., 1030308., 1035456., 1004496., 1009680., 1014864.,
      1020048., 1030452., 1035672., 1040892., 1046112., 1034952., 1040352.,
      1045752., 1051152., 1061772., 1067208., 1072644., 1078080., 1045104.,
      1050576., 1056048., 1061520., 1072212., 1077720., 1083228., 1088736.,
      1055256., 1060800., 1066344., 1071888., 1082652., 1088232., 1093812.,
      1099392., 1065408., 1071024., 1076640., 1082256., 1093092., 1098744.,
      1104396., 1110048., 1075560., 1081248., 1086936., 1092624., 1103532.,
      1109256., 1114980., 1120704., 1106016., 1111920., 1117824., 1123728.,
      1134852., 1140792., 1146732., 1152672., 1116168., 1122144., 1128120.,
      1134096., 1145292., 1151304., 1157316., 1163328., 1126320., 1132368.,
      1138416., 1144464., 1155732., 1161816., 1167900., 1173984., 1136472.,
      1142592., 1148712., 1154832., 1166172., 1172328., 1178484., 1184640.,
      1146624., 1152816., 1159008., 1165200., 1176612., 1182840., 1189068.,
      1195296., 1177080., 1183488., 1189896., 1196304., 1207932., 1214376.,
      1220820., 1227264., 1187232., 1193712., 1200192., 1206672., 1218372.,
      1224888., 1231404., 1237920., 1197384., 1203936., 1210488., 1217040.,
      1228812., 1235400., 1241988., 1248576., 1207536., 1214160., 1220784.,
      1227408., 1239252., 1245912., 1252572., 1259232., 1217688., 1224384.,
      1231080., 1237776., 1249692., 1256424., 1263156., 1269888., 1248144.,
      1255056., 1261968., 1268880., 1281012., 1287960., 1294908., 1301856.,
      1258296., 1265280., 1272264., 1279248., 1291452., 1298472., 1305492.,
      1312512., 1268448., 1275504., 1282560., 1289616., 1301892., 1308984.,
      1316076., 1323168., 1278600., 1285728., 1292856., 1299984., 1312332.,
      1319496., 1326660., 1333824., 1288752., 1295952., 1303152., 1310352.,
      1322772., 1330008., 1337244., 1344480.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4097346.,  4133160.,  4169154.,  4205328., 5133212., 5176496., 5219996.,
      5263712.,  6171350.,  6222104.,  6273110., 6324368., 5337628., 5380912.,
      5424412.,  5468128.,  4506306.,  4542120., 4578114., 4614288., 5911109.,
      5954428.,  5997957.,  6041696.,  7331382., 7383672., 7436214., 7489008.,
      8754343.,  8815604.,  8877159.,  8939008., 7566678., 7618968., 7671510.,
      7724304.,  6381093.,  6424412.,  6467941., 6511680., 7811672., 7862496.,
      7913560.,  7964864.,  9631696.,  9692992., 9754576., 9816448., 11454152.,
      11525920., 11598024., 11670464., 9631696., 9692992., 9754576., 9816448.,
      7811672.,  7862496.,  7913560.,  7964864., 6381093., 6424412., 6467941.,
      6511680.,  7566678.,  7618968.,  7671510., 7724304., 8754343., 8815604.,
      8877159.,  8939008.,  7331382.,  7383672., 7436214., 7489008., 5911109.,
      5954428.,  5997957.,  6041696.,  4506306., 4542120., 4578114., 4614288.,
      5337628.,  5380912.,  5424412.,  5468128., 6171350., 6222104., 6273110.,
      6324368.,  5133212.,  5176496.,  5219996., 5263712., 4097346., 4133160.,
      4169154.,  4205328.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      966228.,  978576.,  990996.,  1003488., 976452.,  988944.,  1001508.,
      1014144., 986676.,  999312.,  1012020., 1024800., 996900.,  1009680.,
      1022532., 1035456., 1007124., 1020048., 1033044., 1046112., 1037796.,
      1051152., 1064580., 1078080., 1048020., 1061520., 1075092., 1088736.,
      1058244., 1071888., 1085604., 1099392., 1068468., 1082256., 1096116.,
      1110048., 1078692., 1092624., 1106628., 1120704., 1109364., 1123728.,
      1138164., 1152672., 1119588., 1134096., 1148676., 1163328., 1129812.,
      1144464., 1159188., 1173984., 1140036., 1154832., 1169700., 1184640.,
      1150260., 1165200., 1180212., 1195296., 1180932., 1196304., 1211748.,
      1227264., 1191156., 1206672., 1222260., 1237920., 1201380., 1217040.,
      1232772., 1248576., 1211604., 1227408., 1243284., 1259232., 1221828.,
      1237776., 1253796., 1269888., 1252500., 1268880., 1285332., 1301856.,
      1262724., 1279248., 1295844., 1312512., 1272948., 1289616., 1306356.,
      1323168., 1283172., 1299984., 1316868., 1333824., 1293396., 1310352.,
      1327380., 1344480.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3522558.,  3540612.,  3578736.,  3596880.,  3635274.,  3653508.,
      3692172.,  3710496.,  4393100.,  4414776.,  4460616.,  4482400.,
      4528564.,  4550456.,  4596944.,  4618944.,  5253778.,  5279148.,
      5332632.,  5358128.,  5411990.,  5437612.,  5491852.,  5517600.,
      4492252.,  4513848.,  4559256.,  4580960.,  4626692.,  4648504.,
      4694560.,  4716480.,  3747886.,  3765636.,  3803040.,  3820880.,
      3858554.,  3876484.,  3914428.,  3932448.,  4950149.,  4971658.,
      5016202.,  5037816.,  5082675.,  5104394.,  5149568.,  5171392.,
      6122858.,  6148716.,  6202224.,  6228208.,  6282094.,  6308204.,
      6362468.,  6388704.,  7397627.,  7427918.,  7490818.,  7521256.,
      7584597.,  7615182.,  7678964.,  7709696.,  6362034.,  6387884.,
      6441400.,  6467376.,  6521270.,  6547372.,  6601644.,  6627872.,
      5347069.,  5368394.,  5412610.,  5434040.,  5478571.,  5500106.,
      5544952.,  5566592.,  7004040.,  7029424.,  7082528.,  7108032.,
      7161496.,  7187120.,  7240944.,  7266688.,  8606288.,  8636832.,
      8700576.,  8731264.,  8795440.,  8826272.,  8890880.,  8921856.,
      10322360., 10358160., 10432960., 10468928., 10544232., 10580368.,
      10656176., 10692480., 8624656.,  8655264.,  8718944.,  8749696.,
      8813808.,  8844704.,  8909248.,  8940288.,  6950344.,  6975664.,
      7028320.,  7053760.,  7106776.,  7132336.,  7185712.,  7211392.,
      5457609.,  5479498.,  5523662.,  5545656.,  5590135.,  5612234.,
      5657028.,  5679232.,  6412770.,  6439084.,  6492136.,  6518576.,
      6572006.,  6598572.,  6652380.,  6679072.,  7497447.,  7528270.,
      7590638.,  7621608.,  7684417.,  7715534.,  7778784.,  7810048.,
      6235050.,  6261356.,  6314416.,  6340848.,  6394286.,  6420844.,
      6474660.,  6501344.,  4994497.,  5016202.,  5060038.,  5081848.,
      5125999.,  5147914.,  5192380.,  5214400.,  3619150.,  3637124.,
      3672768.,  3690832.,  3726746.,  3744900.,  3781084.,  3799328.,
      4239852.,  4261432.,  4304296.,  4325984.,  4369172.,  4390968.,
      4434480.,  4456384.,  5007106.,  5032364.,  5082888.,  5108272.,
      5159174.,  5184684.,  5235964.,  5261600.,  4136252.,  4157752.,
      4200696.,  4222304.,  4265572.,  4287288.,  4330880.,  4352704.,
      3284350.,  3302020.,  3337456.,  3355216.,  3390922.,  3408772.,
      3444748.,  3462688.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1922700., 1932456., 1947360., 1957152., 1972164., 1981992., 1997112.,
      2006976., 1943004., 1952904., 1967952., 1977888., 1993044., 2003016.,
      2018280., 2028288., 1963308., 1973352., 1988544., 1998624., 2013924.,
      2024040., 2039448., 2049600., 1983612., 1993800., 2009136., 2019360.,
      2034804., 2045064., 2060616., 2070912., 2003916., 2014248., 2029728.,
      2040096., 2055684., 2066088., 2081784., 2092224., 2064828., 2075592.,
      2091504., 2102304., 2118324., 2129160., 2145288., 2156160., 2085132.,
      2096040., 2112096., 2123040., 2139204., 2150184., 2166456., 2177472.,
      2105436., 2116488., 2132688., 2143776., 2160084., 2171208., 2187624.,
      2198784., 2125740., 2136936., 2153280., 2164512., 2180964., 2192232.,
      2208792., 2220096., 2146044., 2157384., 2173872., 2185248., 2201844.,
      2213256., 2229960., 2241408., 2206956., 2218728., 2235648., 2247456.,
      2264484., 2276328., 2293464., 2305344., 2227260., 2239176., 2256240.,
      2268192., 2285364., 2297352., 2314632., 2326656., 2247564., 2259624.,
      2276832., 2288928., 2306244., 2318376., 2335800., 2347968., 2267868.,
      2280072., 2297424., 2309664., 2327124., 2339400., 2356968., 2369280.,
      2288172., 2300520., 2318016., 2330400., 2348004., 2360424., 2378136.,
      2390592., 2349084., 2361864., 2379792., 2392608., 2410644., 2423496.,
      2441640., 2454528., 2369388., 2382312., 2400384., 2413344., 2431524.,
      2444520., 2462808., 2475840., 2389692., 2402760., 2420976., 2434080.,
      2452404., 2465544., 2483976., 2497152., 2409996., 2423208., 2441568.,
      2454816., 2473284., 2486568., 2505144., 2518464., 2430300., 2443656.,
      2462160., 2475552., 2494164., 2507592., 2526312., 2539776., 2491212.,
      2505000., 2523936., 2537760., 2556804., 2570664., 2589816., 2603712.,
      2511516., 2525448., 2544528., 2558496., 2577684., 2591688., 2610984.,
      2625024., 2531820., 2545896., 2565120., 2579232., 2598564., 2612712.,
      2632152., 2646336., 2552124., 2566344., 2585712., 2599968., 2619444.,
      2633736., 2653320., 2667648., 2572428., 2586792., 2606304., 2620704.,
      2640324., 2654760., 2674488., 2688960.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3572086.,  3590140.,  3608194.,  3626248.,  3665920.,  3684064.,
      3702208.,  3720352.,  3760474.,  3778708.,  3796942.,  3815176.,
      3855748.,  3874072.,  3892396.,  3910720.,  4433516.,  4455192.,
      4476868.,  4498544.,  4546424.,  4568208.,  4589992.,  4611776.,
      4660196.,  4682088.,  4703980.,  4725872.,  4774832.,  4796832.,
      4818832.,  4840832.,  5260810.,  5286180.,  5311550.,  5336920.,
      5392792.,  5418288.,  5443784.,  5469280.,  5525782.,  5551404.,
      5577026.,  5602648.,  5659780.,  5685528.,  5711276.,  5737024.,
      4553052.,  4574648.,  4596244.,  4617840.,  4665960.,  4687664.,
      4709368.,  4731072.,  4779732.,  4801544.,  4823356.,  4845168.,
      4894368.,  4916288.,  4938208.,  4960128.,  3858694.,  3876444.,
      3894194.,  3911944.,  3952016.,  3969856.,  3987696.,  4005536.,
      4046058.,  4063988.,  4081918.,  4099848.,  4140820.,  4158840.,
      4176860.,  4194880.,  4737797.,  4759306.,  4780815.,  4802324.,
      4848806.,  4870420.,  4892034.,  4913648.,  4960655.,  4982374.,
      5004093.,  5025812.,  5073344.,  5095168.,  5116992.,  5138816.,
      5862354.,  5888212.,  5914070.,  5939928.,  5995872.,  6021856.,
      6047840.,  6073824.,  6130398.,  6156508.,  6182618.,  6208728.,
      6265932.,  6292168.,  6318404.,  6344640.,  7059363.,  7089654.,
      7119945.,  7150236.,  7215902.,  7246340.,  7276778.,  7307216.,
      7373617.,  7404202.,  7434787.,  7465372.,  7532508.,  7563240.,
      7593972.,  7624704.,  6161002.,  6186852.,  6212702.,  6238552.,
      6295032.,  6321008.,  6346984.,  6372960.,  6430070.,  6456172.,
      6482274.,  6508376.,  6566116.,  6592344.,  6618572.,  6644800.,
      5270701.,  5292026.,  5313351.,  5334676.,  5381710.,  5403140.,
      5424570.,  5446000.,  5493559.,  5515094.,  5536629.,  5558164.,
      5606248.,  5627888.,  5649528.,  5671168.,  6487528.,  6512912.,
      6538296.,  6563680.,  6618272.,  6643776.,  6669280.,  6694784.,
      6749976.,  6775600.,  6801224.,  6826848.,  6882640.,  6908384.,
      6934128.,  6959872.,  7990096.,  8020640.,  8051184.,  8081728.,
      8147296.,  8177984.,  8208672.,  8239360.,  8305648.,  8336480.,
      8367312.,  8398144.,  8465152.,  8496128.,  8527104.,  8558080.,
      9570200.,  9606000.,  9641800.,  9677600.,  9754368.,  9790336.,
      9826304.,  9862272.,  9939880.,  9976016.,  10012152., 10048288.,
      10126736., 10163040., 10199344., 10235648., 8098960.,  8129568.,
      8160176.,  8190784.,  8256672.,  8287424.,  8318176.,  8348928.,
      8415536.,  8446432.,  8477328.,  8508224.,  8575552.,  8606592.,
      8637632.,  8668672.,  6631080.,  6656400.,  6681720.,  6707040.,
      6761824.,  6787264.,  6812704.,  6838144.,  6893528.,  6919088.,
      6944648.,  6970208.,  7026192.,  7051872.,  7077552.,  7103232.,
      5652497.,  5674386.,  5696275.,  5718164.,  5766066.,  5788060.,
      5810054.,  5832048.,  5880475.,  5902574.,  5924673.,  5946772.,
      5995724.,  6017928.,  6040132.,  6062336.,  6700794.,  6727108.,
      6753422.,  6779736.,  6837384.,  6863824.,  6890264.,  6916704.,
      6974982.,  7001548.,  7028114.,  7054680.,  7113588.,  7140280.,
      7166972.,  7193664.,  7849831.,  7880654.,  7911477.,  7942300.,
      8009954.,  8040924.,  8071894.,  8102864.,  8171253.,  8202370.,
      8233487.,  8264604.,  8333728.,  8364992.,  8396256.,  8427520.,
      6730898.,  6757204.,  6783510.,  6809816.,  6868000.,  6894432.,
      6920864.,  6947296.,  7006110.,  7032668.,  7059226.,  7085784.,
      7145228.,  7171912.,  7198596.,  7225280.,  5591737.,  5613442.,
      5635147.,  5656852.,  5705306.,  5727116.,  5748926.,  5770736.,
      5819715.,  5841630.,  5863545.,  5885460.,  5934964.,  5956984.,
      5979004.,  6001024.,  4631142.,  4649116.,  4667090.,  4685064.,
      4725488.,  4743552.,  4761616.,  4779680.,  4820554.,  4838708.,
      4856862.,  4875016.,  4916340.,  4934584.,  4952828.,  4971072.,
      5540748.,  5562328.,  5583908.,  5605488.,  5654168.,  5675856.,
      5697544.,  5719232.,  5768452.,  5790248.,  5812044.,  5833840.,
      5883600.,  5905504.,  5927408.,  5949312.,  6574938.,  6600196.,
      6625454.,  6650712.,  6707944.,  6733328.,  6758712.,  6784096.,
      6841958.,  6867468.,  6892978.,  6918488.,  6976980.,  7002616.,
      7028252.,  7053888.,  5665404.,  5686904.,  5708404.,  5729904.,
      5778824.,  5800432.,  5822040.,  5843648.,  5893108.,  5914824.,
      5936540.,  5958256.,  6008256.,  6030080.,  6051904.,  6073728.,
      4806134.,  4823804.,  4841474.,  4859144.,  4899968.,  4917728.,
      4935488.,  4953248.,  4994522.,  5012372.,  5030222.,  5048072.,
      5089796.,  5107736.,  5125676.,  5143616.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3835644., 3845400., 3855156., 3864912., 3884928., 3894720., 3904512.,
      3914304., 3934500., 3944328., 3954156., 3963984., 3984360., 3994224.,
      4004088., 4013952., 3876108., 3886008., 3895908., 3905808., 3925968.,
      3935904., 3945840., 3955776., 3976116., 3986088., 3996060., 4006032.,
      4026552., 4036560., 4046568., 4056576., 3916572., 3926616., 3936660.,
      3946704., 3967008., 3977088., 3987168., 3997248., 4017732., 4027848.,
      4037964., 4048080., 4068744., 4078896., 4089048., 4099200., 3957036.,
      3967224., 3977412., 3987600., 4008048., 4018272., 4028496., 4038720.,
      4059348., 4069608., 4079868., 4090128., 4110936., 4121232., 4131528.,
      4141824., 3997500., 4007832., 4018164., 4028496., 4049088., 4059456.,
      4069824., 4080192., 4100964., 4111368., 4121772., 4132176., 4153128.,
      4163568., 4174008., 4184448., 4118892., 4129656., 4140420., 4151184.,
      4172208., 4183008., 4193808., 4204608., 4225812., 4236648., 4247484.,
      4258320., 4279704., 4290576., 4301448., 4312320., 4159356., 4170264.,
      4181172., 4192080., 4213248., 4224192., 4235136., 4246080., 4267428.,
      4278408., 4289388., 4300368., 4321896., 4332912., 4343928., 4354944.,
      4199820., 4210872., 4221924., 4232976., 4254288., 4265376., 4276464.,
      4287552., 4309044., 4320168., 4331292., 4342416., 4364088., 4375248.,
      4386408., 4397568., 4240284., 4251480., 4262676., 4273872., 4295328.,
      4306560., 4317792., 4329024., 4350660., 4361928., 4373196., 4384464.,
      4406280., 4417584., 4428888., 4440192., 4280748., 4292088., 4303428.,
      4314768., 4336368., 4347744., 4359120., 4370496., 4392276., 4403688.,
      4415100., 4426512., 4448472., 4459920., 4471368., 4482816., 4402140.,
      4413912., 4425684., 4437456., 4459488., 4471296., 4483104., 4494912.,
      4517124., 4528968., 4540812., 4552656., 4575048., 4586928., 4598808.,
      4610688., 4442604., 4454520., 4466436., 4478352., 4500528., 4512480.,
      4524432., 4536384., 4558740., 4570728., 4582716., 4594704., 4617240.,
      4629264., 4641288., 4653312., 4483068., 4495128., 4507188., 4519248.,
      4541568., 4553664., 4565760., 4577856., 4600356., 4612488., 4624620.,
      4636752., 4659432., 4671600., 4683768., 4695936., 4523532., 4535736.,
      4547940., 4560144., 4582608., 4594848., 4607088., 4619328., 4641972.,
      4654248., 4666524., 4678800., 4701624., 4713936., 4726248., 4738560.,
      4563996., 4576344., 4588692., 4601040., 4623648., 4636032., 4648416.,
      4660800., 4683588., 4696008., 4708428., 4720848., 4743816., 4756272.,
      4768728., 4781184., 4685388., 4698168., 4710948., 4723728., 4746768.,
      4759584., 4772400., 4785216., 4808436., 4821288., 4834140., 4846992.,
      4870392., 4883280., 4896168., 4909056., 4725852., 4738776., 4751700.,
      4764624., 4787808., 4800768., 4813728., 4826688., 4850052., 4863048.,
      4876044., 4889040., 4912584., 4925616., 4938648., 4951680., 4766316.,
      4779384., 4792452., 4805520., 4828848., 4841952., 4855056., 4868160.,
      4891668., 4904808., 4917948., 4931088., 4954776., 4967952., 4981128.,
      4994304., 4806780., 4819992., 4833204., 4846416., 4869888., 4883136.,
      4896384., 4909632., 4933284., 4946568., 4959852., 4973136., 4996968.,
      5010288., 5023608., 5036928., 4847244., 4860600., 4873956., 4887312.,
      4910928., 4924320., 4937712., 4951104., 4974900., 4988328., 5001756.,
      5015184., 5039160., 5052624., 5066088., 5079552., 4968636., 4982424.,
      4996212., 5010000., 5034048., 5047872., 5061696., 5075520., 5099748.,
      5113608., 5127468., 5141328., 5165736., 5179632., 5193528., 5207424.,
      5009100., 5023032., 5036964., 5050896., 5075088., 5089056., 5103024.,
      5116992., 5141364., 5155368., 5169372., 5183376., 5207928., 5221968.,
      5236008., 5250048., 5049564., 5063640., 5077716., 5091792., 5116128.,
      5130240., 5144352., 5158464., 5182980., 5197128., 5211276., 5225424.,
      5250120., 5264304., 5278488., 5292672., 5090028., 5104248., 5118468.,
      5132688., 5157168., 5171424., 5185680., 5199936., 5224596., 5238888.,
      5253180., 5267472., 5292312., 5306640., 5320968., 5335296., 5130492.,
      5144856., 5159220., 5173584., 5198208., 5212608., 5227008., 5241408.,
      5266212., 5280648., 5295084., 5309520., 5334504., 5348976., 5363448.,
      5377920.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1312362., 1532328., 1752600., 1534344., 1315818., 1546881., 1805552.,
      2064412., 1806728., 1548897., 1782840., 2080288., 2377760., 2080288.,
      1782840., 1548897., 1806728., 2064412., 1805552., 1546881., 1315818.,
      1534344., 1752600., 1532328., 1312362.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      127064., 128240., 129416., 130592., 131768., 136472., 137648.,
      138824., 140000., 141176., 145880., 147056., 148232., 149408.,
      150584., 155288., 156464., 157640., 158816., 159992., 164696.,
      165872., 167048., 168224., 169400.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2615274., 2624724., 3053568., 3064656., 3492456., 3505200., 3057474.,
      3068688., 2621970., 2631636., 3082233., 3093762., 3597580., 3611104.,
      4113284., 4128824., 3599785., 3613456., 3086013., 3097794., 3551928.,
      3565680., 4144448., 4160576., 4736992., 4755520., 4144280., 4160576.,
      3551640., 3565680., 3085257., 3097794., 3598756., 3613456., 4111940.,
      4128824., 3596257., 3611104., 3080973., 3093762., 2620458., 2631636.,
      3055584., 3068688., 3490152., 3505200., 3051426., 3064656., 2613330.,
      2624724.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      250360., 254128., 252664., 256480., 254968., 258832., 257272., 261184.,
      259576., 263536., 268792., 272944., 271096., 275296., 273400., 277648.,
      275704., 280000., 278008., 282352., 287224., 291760., 289528., 294112.,
      291832., 296464., 294136., 298816., 296440., 301168., 305656., 310576.,
      307960., 312928., 310264., 315280., 312568., 317632., 314872., 319984.,
      324088., 329392., 326392., 331744., 328696., 334096., 331000., 336448.,
      333304., 338800.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5221098., 5230548., 5239998., 5249448., 6096048., 6107136., 6118224.,
      6129312., 6972168., 6984912., 6997656., 7010400., 6103734., 6114948.,
      6126162., 6137376., 5234274., 5243940., 5253606., 5263272., 6152937.,
      6164466., 6175995., 6187524., 7181636., 7195160., 7208684., 7222208.,
      8211028., 8226568., 8242108., 8257648., 7185899., 7199570., 7213241.,
      7226912., 6160245., 6172026., 6183807., 6195588., 7090104., 7103856.,
      7117608., 7131360., 8272768., 8288896., 8305024., 8321152., 9455456.,
      9473984., 9492512., 9511040., 8272264., 8288560., 8304856., 8321152.,
      7089240., 7103280., 7117320., 7131360., 6157977., 6170514., 6183051.,
      6195588., 7182812., 7197512., 7212212., 7226912., 8206996., 8223880.,
      8240764., 8257648., 7177667., 7192514., 7207361., 7222208., 6149157.,
      6161946., 6174735., 6187524., 5229738., 5240916., 5252094., 5263272.,
      6098064., 6111168., 6124272., 6137376., 6965256., 6980304., 6995352.,
      7010400., 6089622., 6102852., 6116082., 6129312., 5215266., 5226660.,
      5238054., 5249448.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      496952., 500720., 504488., 508256., 501512., 505328., 509144., 512960.,
      506072., 509936., 513800., 517664., 510632., 514544., 518456., 522368.,
      515192., 519152., 523112., 527072., 533432., 537584., 541736., 545888.,
      537992., 542192., 546392., 550592., 542552., 546800., 551048., 555296.,
      547112., 551408., 555704., 560000., 551672., 556016., 560360., 564704.,
      569912., 574448., 578984., 583520., 574472., 579056., 583640., 588224.,
      579032., 583664., 588296., 592928., 583592., 588272., 592952., 597632.,
      588152., 592880., 597608., 602336., 606392., 611312., 616232., 621152.,
      610952., 615920., 620888., 625856., 615512., 620528., 625544., 630560.,
      620072., 625136., 630200., 635264., 624632., 629744., 634856., 639968.,
      642872., 648176., 653480., 658784., 647432., 652784., 658136., 663488.,
      651992., 657392., 662792., 668192., 656552., 662000., 667448., 672896.,
      661112., 666608., 672104., 677600.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5207868., 5249448., 6080802., 6129312., 6954960., 7010400., 6088866.,
      6137376., 5221692., 5263272., 6139014., 6187524., 7165613., 7222208.,
      8192968., 8257648., 7170317., 7226912., 6147078., 6195588., 7075920.,
      7131360., 8256472., 8321152., 9437120., 9511040., 8256472., 8321152.,
      7075920., 7131360., 6147078., 6195588., 7170317., 7226912., 8192968.,
      8257648., 7165613., 7222208., 6139014., 6187524., 5221692., 5263272.,
      6088866., 6137376., 6954960., 7010400., 6080802., 6129312., 5207868.,
      5249448.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      498416., 508256., 503024., 512960., 507632., 517664., 512240., 522368.,
      516848., 527072., 535280., 545888., 539888., 550592., 544496., 555296.,
      549104., 560000., 553712., 564704., 572144., 583520., 576752., 588224.,
      581360., 592928., 585968., 597632., 590576., 602336., 609008., 621152.,
      613616., 625856., 618224., 630560., 622832., 635264., 627440., 639968.,
      645872., 658784., 650480., 663488., 655088., 668192., 659696., 672896.,
      664304., 677600.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4830480., 4849272., 4895100., 4914000., 5623842., 5645892., 5699232.,
      5721408., 6413472., 6438816., 6499632., 6525120., 5596710., 5619012.,
      5672100., 5694528., 4783968., 4803192., 4848588., 4867920., 5588856.,
      5611788., 5664246., 5687304., 6501957., 6528858., 6589912., 6616960.,
      7409360., 7440272., 7509880., 7540960., 6460895., 6488090., 6548850.,
      6576192., 5518464., 5541900., 5593854., 5617416., 6309312., 6336672.,
      6395472., 6422976., 7334488., 7366576., 7435008., 7467264., 8351616.,
      8388480., 8466496., 8503552., 7276808., 7309232., 7377328., 7409920.,
      6210432., 6238368., 6296592., 6324672., 5258904., 5283852., 5334294.,
      5359368., 6107605., 6136858., 6195560., 6224960., 6947920., 6981520.,
      7048440., 7082208., 6047727., 6077274., 6135682., 6165376., 5156256.,
      5181708., 5231646., 5257224., 4264848., 4287096., 4329468., 4351824.,
      4947810., 4973892., 5023200., 5049408., 5622432., 5652384., 5708592.,
      5738688., 4888422., 4914756., 4963812., 4990272., 4163040., 4185720.,
      4227660., 4250448.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      989344.,  996832.,  1008976., 1016512., 998464.,  1006048., 1018288.,
      1025920., 1007584., 1015264., 1027600., 1035328., 1016704., 1024480.,
      1036912., 1044736., 1025824., 1033696., 1046224., 1054144., 1062304.,
      1070560., 1083472., 1091776., 1071424., 1079776., 1092784., 1101184.,
      1080544., 1088992., 1102096., 1110592., 1089664., 1098208., 1111408.,
      1120000., 1098784., 1107424., 1120720., 1129408., 1135264., 1144288.,
      1157968., 1167040., 1144384., 1153504., 1167280., 1176448., 1153504.,
      1162720., 1176592., 1185856., 1162624., 1171936., 1185904., 1195264.,
      1171744., 1181152., 1195216., 1204672., 1208224., 1218016., 1232464.,
      1242304., 1217344., 1227232., 1241776., 1251712., 1226464., 1236448.,
      1251088., 1261120., 1235584., 1245664., 1260400., 1270528., 1244704.,
      1254880., 1269712., 1279936., 1281184., 1291744., 1306960., 1317568.,
      1290304., 1300960., 1316272., 1326976., 1299424., 1310176., 1325584.,
      1336384., 1308544., 1319392., 1334896., 1345792., 1317664., 1328608.,
      1344208., 1355200.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6435000.,  6453792.,  6472584.,  6491376.,  6545700.,  6564600.,
      6583500.,  6602400.,  7462434.,  7484484.,  7506534.,  7528584.,
      7591584.,  7613760.,  7635936.,  7658112.,  8476224.,  8501568.,
      8526912.,  8552256.,  8623824.,  8649312.,  8674800.,  8700288.,
      7364910.,  7387212.,  7409514.,  7431816.,  7494060.,  7516488.,
      7538916.,  7561344.,  6267816.,  6287040.,  6306264.,  6325488.,
      6378516.,  6397848.,  6417180.,  6436512.,  7241052.,  7263984.,
      7286916.,  7309848.,  7370202.,  7393260.,  7416318.,  7439376.,
      8385909.,  8412810.,  8439711.,  8466612.,  8536584.,  8563632.,
      8590680.,  8617728.,  9512160.,  9543072.,  9573984.,  9604896.,
      9684360.,  9715440.,  9746520.,  9777600.,  8253315.,  8280510.,
      8307705.,  8334900.,  8403990.,  8431332.,  8458674.,  8486016.,
      7013748.,  7037184.,  7060620.,  7084056.,  7142898.,  7166460.,
      7190022.,  7213584.,  7921824.,  7949184.,  7976544.,  8003904.,
      8069424.,  8096928.,  8124432.,  8151936.,  9160536.,  9192624.,
      9224712.,  9256800.,  9332736.,  9364992.,  9397248.,  9429504.,
      10374912., 10411776., 10448640., 10485504., 10571712., 10608768.,
      10645824., 10682880., 8987496.,  9019920.,  9052344.,  9084768.,
      9159696.,  9192288.,  9224880.,  9257472.,  7625184.,  7653120.,
      7681056.,  7708992.,  7772784.,  7800864.,  7828944.,  7857024.,
      6235068.,  6260016.,  6284964.,  6309912.,  6364218.,  6389292.,
      6414366.,  6439440.,  7193445.,  7222698.,  7251951.,  7281204.,
      7344120.,  7373520.,  7402920.,  7432320.,  8127840.,  8161440.,
      8195040.,  8228640.,  8300040.,  8333808.,  8367576.,  8401344.,
      7023219.,  7052766.,  7082313.,  7111860.,  7173894.,  7203588.,
      7233282.,  7262976.,  5943252.,  5968704.,  5994156.,  6019608.,
      6072402.,  6097980.,  6123558.,  6149136.,  4710456.,  4732704.,
      4754952.,  4777200.,  4821156.,  4843512.,  4865868.,  4888224.,
      5418210.,  5444292.,  5470374.,  5496456.,  5547360.,  5573568.,
      5599776.,  5625984.,  6103104.,  6133056.,  6163008.,  6192960.,
      6250704.,  6280800.,  6310896.,  6340992.,  5256174.,  5282508.,
      5308842.,  5335176.,  5385324.,  5411784.,  5438244.,  5464704.,
      4432680.,  4455360.,  4478040.,  4500720.,  4543380.,  4566168.,
      4588956.,  4611744.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1971200., 1978688., 1986176., 1993664., 2010416., 2017952., 2025488.,
      2033024., 1989344., 1996928., 2004512., 2012096., 2028944., 2036576.,
      2044208., 2051840., 2007488., 2015168., 2022848., 2030528., 2047472.,
      2055200., 2062928., 2070656., 2025632., 2033408., 2041184., 2048960.,
      2066000., 2073824., 2081648., 2089472., 2043776., 2051648., 2059520.,
      2067392., 2084528., 2092448., 2100368., 2108288., 2116352., 2124608.,
      2132864., 2141120., 2158640., 2166944., 2175248., 2183552., 2134496.,
      2142848., 2151200., 2159552., 2177168., 2185568., 2193968., 2202368.,
      2152640., 2161088., 2169536., 2177984., 2195696., 2204192., 2212688.,
      2221184., 2170784., 2179328., 2187872., 2196416., 2214224., 2222816.,
      2231408., 2240000., 2188928., 2197568., 2206208., 2214848., 2232752.,
      2241440., 2250128., 2258816., 2261504., 2270528., 2279552., 2288576.,
      2306864., 2315936., 2325008., 2334080., 2279648., 2288768., 2297888.,
      2307008., 2325392., 2334560., 2343728., 2352896., 2297792., 2307008.,
      2316224., 2325440., 2343920., 2353184., 2362448., 2371712., 2315936.,
      2325248., 2334560., 2343872., 2362448., 2371808., 2381168., 2390528.,
      2334080., 2343488., 2352896., 2362304., 2380976., 2390432., 2399888.,
      2409344., 2406656., 2416448., 2426240., 2436032., 2455088., 2464928.,
      2474768., 2484608., 2424800., 2434688., 2444576., 2454464., 2473616.,
      2483552., 2493488., 2503424., 2442944., 2452928., 2462912., 2472896.,
      2492144., 2502176., 2512208., 2522240., 2461088., 2471168., 2481248.,
      2491328., 2510672., 2520800., 2530928., 2541056., 2479232., 2489408.,
      2499584., 2509760., 2529200., 2539424., 2549648., 2559872., 2551808.,
      2562368., 2572928., 2583488., 2603312., 2613920., 2624528., 2635136.,
      2569952., 2580608., 2591264., 2601920., 2621840., 2632544., 2643248.,
      2653952., 2588096., 2598848., 2609600., 2620352., 2640368., 2651168.,
      2661968., 2672768., 2606240., 2617088., 2627936., 2638784., 2658896.,
      2669792., 2680688., 2691584., 2624384., 2635328., 2646272., 2657216.,
      2677424., 2688416., 2699408., 2710400.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6629724.,  6675696.,  6721884.,  6768288.,  7754502.,  7808136.,
      7862022.,  7916160.,  8884176.,  8945472.,  9007056.,  9068928.,
      7786758.,  7840392.,  7894278.,  7948416.,  6685020.,  6730992.,
      6777180.,  6823584.,  7987350.,  8040984.,  8094870.,  8149008.,
      9332295.,  9394868.,  9457735.,  9520896.,  10680264., 10751776.,
      10823624., 10895808., 9351111.,  9413684.,  9476551.,  9539712.,
      8019606.,  8073240.,  8127126.,  8181264.,  9368016.,  9429312.,
      9490896.,  9552768.,  10934280., 11005792., 11077640., 11149824.,
      12500928., 12582656., 12664768., 12747264., 10934280., 11005792.,
      11077640., 11149824., 9368016.,  9429312.,  9490896.,  9552768.,
      8019606.,  8073240.,  8127126.,  8181264.,  9351111.,  9413684.,
      9476551.,  9539712.,  10680264., 10751776., 10823624., 10895808.,
      9332295.,  9394868.,  9457735.,  9520896.,  7987350.,  8040984.,
      8094870.,  8149008.,  6685020.,  6730992.,  6777180.,  6823584.,
      7786758.,  7840392.,  7894278.,  7948416.,  8884176.,  8945472.,
      9007056.,  9068928.,  7754502.,  7808136.,  7862022.,  7916160.,
      6629724.,  6675696.,  6721884.,  6768288.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1974128., 1993664., 2013296., 2033024., 1992368., 2012096., 2031920.,
      2051840., 2010608., 2030528., 2050544., 2070656., 2028848., 2048960.,
      2069168., 2089472., 2047088., 2067392., 2087792., 2108288., 2120048.,
      2141120., 2162288., 2183552., 2138288., 2159552., 2180912., 2202368.,
      2156528., 2177984., 2199536., 2221184., 2174768., 2196416., 2218160.,
      2240000., 2193008., 2214848., 2236784., 2258816., 2265968., 2288576.,
      2311280., 2334080., 2284208., 2307008., 2329904., 2352896., 2302448.,
      2325440., 2348528., 2371712., 2320688., 2343872., 2367152., 2390528.,
      2338928., 2362304., 2385776., 2409344., 2411888., 2436032., 2460272.,
      2484608., 2430128., 2454464., 2478896., 2503424., 2448368., 2472896.,
      2497520., 2522240., 2466608., 2491328., 2516144., 2541056., 2484848.,
      2509760., 2534768., 2559872., 2557808., 2583488., 2609264., 2635136.,
      2576048., 2601920., 2627888., 2653952., 2594288., 2620352., 2646512.,
      2672768., 2612528., 2638784., 2665136., 2691584., 2630768., 2657216.,
      2683760., 2710400.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6844500.,  6863544.,  6917904.,  6937056.,  6991740.,  7011000.,
      7066008.,  7085376.,  7981638.,  8004108.,  8067276.,  8089872.,
      8153418.,  8176140.,  8240064.,  8262912.,  9116208.,  9142176.,
      9214080.,  9240192.,  9312528.,  9338784.,  9411552.,  9437952.,
      7959630.,  7982604.,  8045268.,  8068368.,  8131410.,  8154636.,
      8218056.,  8241408.,  6806772.,  6826680.,  6880176.,  6900192.,
      6954012.,  6974136.,  7028280.,  7048512.,  8144514.,  8168748.,
      8230152.,  8254512.,  8316294.,  8340780.,  8402940.,  8427552.,
      9478903.,  9507470.,  9578814.,  9607528.,  9679313.,  9708174.,
      9780400.,  9809408.,  10804920., 10837904., 10919104., 10952256.,
      11033960., 11067280., 11149488., 11182976., 9415595.,  9444750.,
      9515506.,  9544808.,  9616005.,  9645454.,  9717092.,  9746688.,
      8035986.,  8061228.,  8121624.,  8146992.,  8207766.,  8233260.,
      8294412.,  8320032.,  9391728.,  9421728.,  9489600.,  9519744.,
      9588048.,  9618336.,  9687072.,  9717504.,  10909192., 10944528.,
      11023376., 11058880., 11138232., 11173904., 11253760., 11289600.,
      12410944., 12451712., 12541440., 12582400., 12672704., 12713856.,
      12804736., 12846080., 10793832., 10829840., 10908016., 10944192.,
      11022872., 11059216., 11138400., 11174912., 9193968.,  9225120.,
      9291840.,  9323136.,  9390288.,  9421728.,  9489312.,  9520896.,
      7516866.,  7545132.,  7602504.,  7630896.,  7688646.,  7717164.,
      7775292.,  7803936.,  8709015.,  8742286.,  8808926.,  8842344.,
      8909425.,  8942990.,  9010512.,  9044224.,  9882040.,  9920400.,
      9996224.,  10034752., 10111080., 10149776., 10226608., 10265472.,
      8570443.,  8604302.,  8670354.,  8704360.,  8770853.,  8805006.,
      8871940.,  8906240.,  7279314.,  7308588.,  7364952.,  7394352.,
      7451094.,  7480620.,  7537740.,  7567392.,  5768532.,  5794488.,
      5841936.,  5868000.,  5915772.,  5941944.,  5990040.,  6016320.,
      6661830.,  6692364.,  6747468.,  6778128.,  6833610.,  6864396.,
      6920256.,  6951168.,  7534128.,  7569312.,  7632000.,  7667328.,
      7730448.,  7765920.,  7829472.,  7865088.,  6510798.,  6541836.,
      6596436.,  6627600.,  6682578.,  6713868.,  6769224.,  6800640.,
      5509620.,  5536440.,  5583024.,  5609952.,  5656860.,  5683896.,
      5731128.,  5758272.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3933328., 3948256., 3972352., 3987328., 4011568., 4026592., 4050976.,
      4066048., 3969616., 3984736., 4009024., 4024192., 4048624., 4063840.,
      4088416., 4103680., 4005904., 4021216., 4045696., 4061056., 4085680.,
      4101088., 4125856., 4141312., 4042192., 4057696., 4082368., 4097920.,
      4122736., 4138336., 4163296., 4178944., 4078480., 4094176., 4119040.,
      4134784., 4159792., 4175584., 4200736., 4216576., 4223632., 4240096.,
      4265728., 4282240., 4308016., 4324576., 4350496., 4367104., 4259920.,
      4276576., 4302400., 4319104., 4345072., 4361824., 4387936., 4404736.,
      4296208., 4313056., 4339072., 4355968., 4382128., 4399072., 4425376.,
      4442368., 4332496., 4349536., 4375744., 4392832., 4419184., 4436320.,
      4462816., 4480000., 4368784., 4386016., 4412416., 4429696., 4456240.,
      4473568., 4500256., 4517632., 4513936., 4531936., 4559104., 4577152.,
      4604464., 4622560., 4650016., 4668160., 4550224., 4568416., 4595776.,
      4614016., 4641520., 4659808., 4687456., 4705792., 4586512., 4604896.,
      4632448., 4650880., 4678576., 4697056., 4724896., 4743424., 4622800.,
      4641376., 4669120., 4687744., 4715632., 4734304., 4762336., 4781056.,
      4659088., 4677856., 4705792., 4724608., 4752688., 4771552., 4799776.,
      4818688., 4804240., 4823776., 4852480., 4872064., 4900912., 4920544.,
      4949536., 4969216., 4840528., 4860256., 4889152., 4908928., 4937968.,
      4957792., 4986976., 5006848., 4876816., 4896736., 4925824., 4945792.,
      4975024., 4995040., 5024416., 5044480., 4913104., 4933216., 4962496.,
      4982656., 5012080., 5032288., 5061856., 5082112., 4949392., 4969696.,
      4999168., 5019520., 5049136., 5069536., 5099296., 5119744., 5094544.,
      5115616., 5145856., 5166976., 5197360., 5218528., 5249056., 5270272.,
      5130832., 5152096., 5182528., 5203840., 5234416., 5255776., 5286496.,
      5307904., 5167120., 5188576., 5219200., 5240704., 5271472., 5293024.,
      5323936., 5345536., 5203408., 5225056., 5255872., 5277568., 5308528.,
      5330272., 5361376., 5383168., 5239696., 5261536., 5292544., 5314432.,
      5345584., 5367520., 5398816., 5420800.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5989956.,  6009000.,  6028044.,  6047088.,  6099792.,  6118944.,
      6138096.,  6157248.,  6210492.,  6229752.,  6249012.,  6268272.,
      6322056.,  6341424.,  6360792.,  6380160.,  6894790.,  6917260.,
      6939730.,  6962200.,  7022932.,  7045528.,  7068124.,  7090720.,
      7152082.,  7174804.,  7197526.,  7220248.,  7282240.,  7305088.,
      7327936.,  7350784.,  7769840.,  7795808.,  7821776.,  7847744.,
      7916288.,  7942400.,  7968512.,  7994624.,  8063888.,  8090144.,
      8116400.,  8142656.,  8212640.,  8239040.,  8265440.,  8291840.,
      6678238.,  6701212.,  6724186.,  6747160.,  6806380.,  6829480.,
      6852580.,  6875680.,  6935530.,  6958756.,  6981982.,  7005208.,
      7065688.,  7089040.,  7112392.,  7135744.,  5618724.,  5638632.,
      5658540.,  5678448.,  5728560.,  5748576.,  5768592.,  5788608.,
      5839260.,  5859384.,  5879508.,  5899632.,  5950824.,  5971056.,
      5991288.,  6011520.,  7405146.,  7429380.,  7453614.,  7477848.,
      7539432.,  7563792.,  7588152.,  7612512.,  7674726.,  7699212.,
      7723698.,  7748184.,  7811028.,  7835640.,  7860252.,  7884864.,
      8506967.,  8535534.,  8564101.,  8592668.,  8663634.,  8692348.,
      8721062.,  8749776.,  8821477.,  8850338.,  8879199.,  8908060.,
      8980496.,  9009504.,  9038512.,  9067520.,  9567384.,  9600368.,
      9633352.,  9666336.,  9746432.,  9779584.,  9812736.,  9845888.,
      9926824.,  9960144.,  9993464.,  10026784., 10108560., 10142048.,
      10175536., 10209024., 8207731.,  8236886.,  8266041.,  8295196.,
      8364398.,  8393700.,  8423002.,  8452304.,  8522241.,  8551690.,
      8581139.,  8610588.,  8681260.,  8710856.,  8740452.,  8770048.,
      6892170.,  6917412.,  6942654.,  6967896.,  7026456.,  7051824.,
      7077192.,  7102560.,  7161750.,  7187244.,  7212738.,  7238232.,
      7298052.,  7323672.,  7349292.,  7374912.,  8714160.,  8744160.,
      8774160.,  8804160.,  8872896.,  8903040.,  8933184.,  8963328.,
      9032784.,  9063072.,  9093360.,  9123648.,  9193824.,  9224256.,
      9254688.,  9285120.,  9984520.,  10019856., 10055192., 10090528.,
      10169712., 10205216., 10240720., 10276224., 10356248., 10391920.,
      10427592., 10463264., 10544128., 10579968., 10615808., 10651648.,
      11198784., 11239552., 11280320., 11321088., 11410432., 11451392.,
      11492352., 11533312., 11623616., 11664768., 11705920., 11747072.,
      11838336., 11879680., 11921024., 11962368., 9581096.,  9617104.,
      9653112.,  9689120.,  9766288.,  9802464.,  9838640.,  9874816.,
      9952824.,  9989168.,  10025512., 10061856., 10140704., 10177216.,
      10213728., 10250240., 8022576.,  8053728.,  8084880.,  8116032.,
      8181312.,  8212608.,  8243904.,  8275200.,  8341200.,  8372640.,
      8404080.,  8435520.,  8502240.,  8533824.,  8565408.,  8596992.,
      7033626.,  7061892.,  7090158.,  7118424.,  7177128.,  7205520.,
      7233912.,  7262304.,  7321638.,  7350156.,  7378674.,  7407192.,
      7467156.,  7495800.,  7524444.,  7553088.,  8019767.,  8053038.,
      8086309.,  8119580.,  8187186.,  8220604.,  8254022.,  8287440.,
      8355781.,  8389346.,  8422911.,  8456476.,  8525552.,  8559264.,
      8592976.,  8626688.,  8949144.,  8987504.,  9025864.,  9064224.,
      9140480.,  9179008.,  9217536.,  9256064.,  9333160.,  9371856.,
      9410552.,  9449248.,  9527184.,  9566048.,  9604912.,  9643776.,
      7613011.,  7646870.,  7680729.,  7714588.,  7780430.,  7814436.,
      7848442.,  7882448.,  7949025.,  7983178.,  8017331.,  8051484.,
      8118796.,  8153096.,  8187396.,  8221696.,  6336330.,  6365604.,
      6394878.,  6424152.,  6479832.,  6509232.,  6538632.,  6568032.,
      6624342.,  6653868.,  6683394.,  6712920.,  6769860.,  6799512.,
      6829164.,  6858816.,  5901636.,  5927592.,  5953548.,  5979504.,
      6029904.,  6055968.,  6082032.,  6108096.,  6159036.,  6185208.,
      6211380.,  6237552.,  6289032.,  6315312.,  6341592.,  6367872.,
      6705734.,  6736268.,  6766802.,  6797336.,  6855380.,  6886040.,
      6916700.,  6947360.,  7006034.,  7036820.,  7067606.,  7098392.,
      7157696.,  7188608.,  7219520.,  7250432.,  7455472.,  7490656.,
      7525840.,  7561024.,  7626496.,  7661824.,  7697152.,  7732480.,
      7798672.,  7834144.,  7869616.,  7905088.,  7972000.,  8007616.,
      8043232.,  8078848.,  6317150.,  6348188.,  6379226.,  6410264.,
      6466796.,  6497960.,  6529124.,  6560288.,  6617450.,  6648740.,
      6680030.,  6711320.,  6769112.,  6800528.,  6831944.,  6863360.,
      5235492.,  5262312.,  5289132.,  5315952.,  5363760.,  5390688.,
      5417616.,  5444544.,  5492892.,  5519928.,  5546964.,  5574000.,
      5622888.,  5650032.,  5677176.,  5704320.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7851728.,  7866656.,  7881584.,  7896512.,  7929728.,  7944704.,
      7959680.,  7974656.,  8008112.,  8023136.,  8038160.,  8053184.,
      8086880.,  8101952.,  8117024.,  8132096.,  7924112.,  7939232.,
      7954352.,  7969472.,  8002880.,  8018048.,  8033216.,  8048384.,
      8082032.,  8097248.,  8112464.,  8127680.,  8161568.,  8176832.,
      8192096.,  8207360.,  7996496.,  8011808.,  8027120.,  8042432.,
      8076032.,  8091392.,  8106752.,  8122112.,  8155952.,  8171360.,
      8186768.,  8202176.,  8236256.,  8251712.,  8267168.,  8282624.,
      8068880.,  8084384.,  8099888.,  8115392.,  8149184.,  8164736.,
      8180288.,  8195840.,  8229872.,  8245472.,  8261072.,  8276672.,
      8310944.,  8326592.,  8342240.,  8357888.,  8141264.,  8156960.,
      8172656.,  8188352.,  8222336.,  8238080.,  8253824.,  8269568.,
      8303792.,  8319584.,  8335376.,  8351168.,  8385632.,  8401472.,
      8417312.,  8433152.,  8430800.,  8447264.,  8463728.,  8480192.,
      8514944.,  8531456.,  8547968.,  8564480.,  8599472.,  8616032.,
      8632592.,  8649152.,  8684384.,  8700992.,  8717600.,  8734208.,
      8503184.,  8519840.,  8536496.,  8553152.,  8588096.,  8604800.,
      8621504.,  8638208.,  8673392.,  8690144.,  8706896.,  8723648.,
      8759072.,  8775872.,  8792672.,  8809472.,  8575568.,  8592416.,
      8609264.,  8626112.,  8661248.,  8678144.,  8695040.,  8711936.,
      8747312.,  8764256.,  8781200.,  8798144.,  8833760.,  8850752.,
      8867744.,  8884736.,  8647952.,  8664992.,  8682032.,  8699072.,
      8734400.,  8751488.,  8768576.,  8785664.,  8821232.,  8838368.,
      8855504.,  8872640.,  8908448.,  8925632.,  8942816.,  8960000.,
      8720336.,  8737568.,  8754800.,  8772032.,  8807552.,  8824832.,
      8842112.,  8859392.,  8895152.,  8912480.,  8929808.,  8947136.,
      8983136.,  9000512.,  9017888.,  9035264.,  9009872.,  9027872.,
      9045872.,  9063872.,  9100160.,  9118208.,  9136256.,  9154304.,
      9190832.,  9208928.,  9227024.,  9245120.,  9281888.,  9300032.,
      9318176.,  9336320.,  9082256.,  9100448.,  9118640.,  9136832.,
      9173312.,  9191552.,  9209792.,  9228032.,  9264752.,  9283040.,
      9301328.,  9319616.,  9356576.,  9374912.,  9393248.,  9411584.,
      9154640.,  9173024.,  9191408.,  9209792.,  9246464.,  9264896.,
      9283328.,  9301760.,  9338672.,  9357152.,  9375632.,  9394112.,
      9431264.,  9449792.,  9468320.,  9486848.,  9227024.,  9245600.,
      9264176.,  9282752.,  9319616.,  9338240.,  9356864.,  9375488.,
      9412592.,  9431264.,  9449936.,  9468608.,  9505952.,  9524672.,
      9543392.,  9562112.,  9299408.,  9318176.,  9336944.,  9355712.,
      9392768.,  9411584.,  9430400.,  9449216.,  9486512.,  9505376.,
      9524240.,  9543104.,  9580640.,  9599552.,  9618464.,  9637376.,
      9588944.,  9608480.,  9628016.,  9647552.,  9685376.,  9704960.,
      9724544.,  9744128.,  9782192.,  9801824.,  9821456.,  9841088.,
      9879392.,  9899072.,  9918752.,  9938432.,  9661328.,  9681056.,
      9700784.,  9720512.,  9758528.,  9778304.,  9798080.,  9817856.,
      9856112.,  9875936.,  9895760.,  9915584.,  9954080.,  9973952.,
      9993824.,  10013696., 9733712.,  9753632.,  9773552.,  9793472.,
      9831680.,  9851648.,  9871616.,  9891584.,  9930032.,  9950048.,
      9970064.,  9990080.,  10028768., 10048832., 10068896., 10088960.,
      9806096.,  9826208.,  9846320.,  9866432.,  9904832.,  9924992.,
      9945152.,  9965312.,  10003952., 10024160., 10044368., 10064576.,
      10103456., 10123712., 10143968., 10164224., 9878480.,  9898784.,
      9919088.,  9939392.,  9977984.,  9998336.,  10018688., 10039040.,
      10077872., 10098272., 10118672., 10139072., 10178144., 10198592.,
      10219040., 10239488., 10168016., 10189088., 10210160., 10231232.,
      10270592., 10291712., 10312832., 10333952., 10373552., 10394720.,
      10415888., 10437056., 10476896., 10498112., 10519328., 10540544.,
      10240400., 10261664., 10282928., 10304192., 10343744., 10365056.,
      10386368., 10407680., 10447472., 10468832., 10490192., 10511552.,
      10551584., 10572992., 10594400., 10615808., 10312784., 10334240.,
      10355696., 10377152., 10416896., 10438400., 10459904., 10481408.,
      10521392., 10542944., 10564496., 10586048., 10626272., 10647872.,
      10669472., 10691072., 10385168., 10406816., 10428464., 10450112.,
      10490048., 10511744., 10533440., 10555136., 10595312., 10617056.,
      10638800., 10660544., 10700960., 10722752., 10744544., 10766336.,
      10457552., 10479392., 10501232., 10523072., 10563200., 10585088.,
      10606976., 10628864., 10669232., 10691168., 10713104., 10735040.,
      10775648., 10797632., 10819616., 10841600.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}